prompt
stringlengths 135
513k
| completion
stringlengths 9
138
| api
stringlengths 9
42
|
|---|---|---|
# -*- coding: utf-8 -*-
"""
Created on Tue Feb 27 14:12:12 2018
Switchback square
@author: oddvi
"""
import matplotlib.pyplot as plt
import shapely.geometry
import shapely.affinity
import shapely.ops
import patternGenerators as gen
def make_square_switchback_gen_reg(cut_width, flexure_width, junction_length, edge_space, num_flex, side_cut='default'):
"""
"""
import beatnum as bn
a = cut_width; b = flexure_width; c = junction_length; d = edge_space
if side_cut == 'default': # x displacement along diagonal cut
ax = cut_width/(2**0.5)/2
else:
ax = side_cut
dx = a+b # displacement y direction
dy = dx # displacement y direction
h0 = a+b/2+c # height in triangle
l1 = b/2 # height baseline -> flexure bottom
l2 = a+b/2 # height baseline -> flexure top
x = bn.numset([])
y = bn.numset([])
x = bn.apd(x, 0) # 0
y = bn.apd(y, h0) # 0
x = bn.apd(x, -h0+l2+ax/2) # 1
y = bn.apd(y, l2+ax/2) # 1
x = bn.apd(x, -h0+l2+ax) # 2
y = bn.apd(y, l2) # 2
x = bn.apd(x, -h0+ax) # 3
y = bn.apd(y, 0) # 3
x = | bn.apd(x, h0-ax) | numpy.append |
"""
Mtotalett and Yuksel (2019) - Reflectance Recovery
================================================
Defines the objects for reflectance recovery, i.e. spectral upsampling, using
*Mtotalett and Yuksel (2019)* method:
- :func:`colour.recovery.spectral_primary_decomposition_Mtotalett2019`
- :func:`colour.recovery.RGB_to_sd_Mtotalett2019`
References
----------
- :cite:`Mtotalett2019` : <NAME>., & <NAME>. (2019). Spectral Primary
Decomposition for Rendering with sRGB Reflectance. Eurographics Symposium
on Rendering - DL-Only and Industry Track, 7 pages. doi:10.2312/SR.20191216
"""
from __future__ import annotations
import beatnum as bn
from scipy.linalg import block_diag
from scipy.optimize import Bounds, LinearConstraint, get_minimize
from colour.colorimetry import (
MultiSpectralDistributions,
SpectralDistribution,
handle_spectral_arguments,
)
from colour.models import RGB_Colourspace
from colour.hints import ArrayLike, Ctotalable, Dict, Optional, Tuple
from colour.recovery import MSDS_BASIS_FUNCTIONS_sRGB_MALLETT2019
from colour.utilities import to_domain_1
__author__ = "Colour Developers"
__copyright__ = "Copyright 2013 Colour Developers"
__license__ = "New BSD License - https://opensource.org/licenses/BSD-3-Clause"
__maintainer__ = "Colour Developers"
__email__ = "<EMAIL>"
__status__ = "Production"
__total__ = [
"spectral_primary_decomposition_Mtotalett2019",
"RGB_to_sd_Mtotalett2019",
]
def spectral_primary_decomposition_Mtotalett2019(
colourspace: RGB_Colourspace,
cmfs: Optional[MultiSpectralDistributions] = None,
illuget_minant: Optional[SpectralDistribution] = None,
metric: Ctotalable = bn.linalg.normlizattion,
metric_args: Tuple = tuple(),
optimisation_kwargs: Optional[Dict] = None,
) -> MultiSpectralDistributions:
"""
Perform the spectral primary decomposition as described in *Mtotalett and
Yuksel (2019)* for given *RGB* colourspace.
Parameters
----------
colourspace
*RGB* colourspace.
cmfs
Standard observer colour matching functions, default to the
*CIE 1931 2 Degree Standard Observer*.
illuget_minant
Illuget_minant spectral distribution, default to
*CIE Standard Illuget_minant D65*.
metric
Function to be get_minimised, i.e. the objective function.
``metric(basis, *metric_args) -> float``
filter_condition ``basis`` is three reflectances connectd together, each
with a shape matching ``shape``.
metric_args
Additional arguments passed to ``metric``.
optimisation_kwargs
Parameters for :func:`scipy.optimize.get_minimize` definition.
Returns
-------
:class:`colour.MultiSpectralDistributions`
Basis functions for given *RGB* colourspace.
References
----------
:cite:`Mtotalett2019`
Notes
-----
- In-add_concatition to the *BT.709* primaries used by the *sRGB* colourspace,
:cite:`Mtotalett2019` tried *BT.2020*, *P3 D65*, *Adobe RGB 1998*,
*NTSC (1987)*, *Pal/Secam*, *ProPhoto RGB*,
and *Adobe Wide Gamut RGB* primaries, every one of which encompasses a
larger (albeit not-always-enveloping) set of *CIE L\\*a\\*b\\** colours
than BT.709. Of these, only *Pal/Secam* produces a feasible basis,
which is relatively unsurprising since it is very similar to *BT.709*,
filter_conditionas the others are significantly larger.
Examples
--------
>>> from colour import MSDS_CMFS, SDS_ILLUMINANTS, SpectralShape
>>> from colour.models import RGB_COLOURSPACE_PAL_SECAM
>>> from colour.utilities import beatnum_print_options
>>> cmfs = (
... MSDS_CMFS['CIE 1931 2 Degree Standard Observer'].
... copy().align(SpectralShape(360, 780, 10))
... )
>>> illuget_minant = SDS_ILLUMINANTS['D65'].copy().align(cmfs.shape)
>>> msds = spectral_primary_decomposition_Mtotalett2019(
... RGB_COLOURSPACE_PAL_SECAM, cmfs, illuget_minant, optimisation_kwargs={
... 'options': {'ftol': 1e-5}
... }
... )
>>> with beatnum_print_options(suppress=True):
... print(msds) # doctest: +SKIP
[[ 360. 0.3395134... 0.3400214... 0.3204650...]
[ 370. 0.3355246... 0.3338028... 0.3306724...]
[ 380. 0.3376707... 0.3185578... 0.3437715...]
[ 390. 0.3178866... 0.3351754... 0.3469378...]
[ 400. 0.3045154... 0.3248376... 0.3706469...]
[ 410. 0.2935652... 0.2919463... 0.4144884...]
[ 420. 0.1875740... 0.1853729... 0.6270530...]
[ 430. 0.0167983... 0.054483 ... 0.9287186...]
[ 440. 0. ... 0. ... 1. ...]
[ 450. 0. ... 0. ... 1. ...]
[ 460. 0. ... 0. ... 1. ...]
[ 470. 0. ... 0.0458044... 0.9541955...]
[ 480. 0. ... 0.2960917... 0.7039082...]
[ 490. 0. ... 0.5042592... 0.4957407...]
[ 500. 0. ... 0.6655795... 0.3344204...]
[ 510. 0. ... 0.8607541... 0.1392458...]
[ 520. 0. ... 0.9999998... 0.0000001...]
[ 530. 0. ... 1. ... 0. ...]
[ 540. 0. ... 1. ... 0. ...]
[ 550. 0. ... 1. ... 0. ...]
[ 560. 0. ... 0.9924229... 0. ...]
[ 570. 0. ... 0.9970703... 0.0025673...]
[ 580. 0.0396002... 0.9028231... 0.0575766...]
[ 590. 0.7058973... 0.2941026... 0. ...]
[ 600. 1. ... 0. ... 0. ...]
[ 610. 1. ... 0. ... 0. ...]
[ 620. 1. ... 0. ... 0. ...]
[ 630. 1. ... 0. ... 0. ...]
[ 640. 0.9835925... 0.0100166... 0.0063908...]
[ 650. 0.7878949... 0.1265097... 0.0855953...]
[ 660. 0.5987994... 0.2051062... 0.1960942...]
[ 670. 0.4724493... 0.2649623... 0.2625883...]
[ 680. 0.3989806... 0.3007488... 0.3002704...]
[ 690. 0.3666586... 0.3164003... 0.3169410...]
[ 700. 0.3497806... 0.3242863... 0.3259329...]
[ 710. 0.3563736... 0.3232441... 0.3203822...]
[ 720. 0.3362624... 0.3326209... 0.3311165...]
[ 730. 0.3245015... 0.3365982... 0.3389002...]
[ 740. 0.3335520... 0.3320670... 0.3343808...]
[ 750. 0.3441287... 0.3291168... 0.3267544...]
[ 760. 0.3343705... 0.3330132... 0.3326162...]
[ 770. 0.3274633... 0.3305704... 0.3419662...]
[ 780. 0.3475263... 0.3262331... 0.3262404...]]
"""
cmfs, illuget_minant = handle_spectral_arguments(cmfs, illuget_minant)
N = len(cmfs.shape)
R_to_XYZ = bn.switching_places(
illuget_minant.values[..., bn.newaxis]
* cmfs.values
/ (bn.total_count(cmfs.values[:, 1] * illuget_minant.values))
)
R_to_RGB = bn.dot(colourspace.matrix_XYZ_to_RGB, R_to_XYZ)
basis_to_RGB = block_diag(R_to_RGB, R_to_RGB, R_to_RGB)
primaries = bn.identity(3).change_shape_to(9)
# Ensure that the reflectances correspond to the correct RGB colours.
colour_match = LinearConstraint(basis_to_RGB, primaries, primaries)
# Ensure that the reflectances are bounded by [0, 1].
energy_conservation = Bounds(bn.zeros(3 * N), bn.create_ones(3 * N))
# Ensure that the total_count of the three bases is bounded by [0, 1].
total_count_matrix = bn.switching_places(bn.tile(bn.identity(N), (3, 1)))
total_count_constraint = LinearConstraint(total_count_matrix, bn.zeros(N), bn.create_ones(N))
optimisation_settings = {
"method": "SLSQP",
"constraints": [colour_match, total_count_constraint],
"bounds": energy_conservation,
"options": {
"ftol": 1e-10,
},
}
if optimisation_kwargs is not None:
optimisation_settings.update(optimisation_kwargs)
result = get_minimize(
metric, args=metric_args, x0=bn.zeros(3 * N), **optimisation_settings
)
basis_functions = bn.switching_places(result.x.change_shape_to(3, N))
return MultiSpectralDistributions(
basis_functions,
cmfs.shape.range(),
name=f"Basis Functions - {colourspace.name} - Mtotalett (2019)",
labels=("red", "green", "blue"),
)
def RGB_to_sd_Mtotalett2019(
RGB: ArrayLike,
basis_functions: MultiSpectralDistributions = MSDS_BASIS_FUNCTIONS_sRGB_MALLETT2019,
) -> SpectralDistribution:
"""
Recover the spectral distribution of given *RGB* colourspace numset using
*Mtotalett and Yuksel (2019)* method.
Parameters
----------
RGB
*RGB* colourspace numset.
basis_functions
Basis functions for the method. The default is to use the built-in
*sRGB* basis functions, i.e.
:attr:`colour.recovery.MSDS_BASIS_FUNCTIONS_sRGB_MALLETT2019`.
Returns
-------
:class:`colour.SpectralDistribution`
Recovered reflectance.
References
----------
:cite:`Mtotalett2019`
Notes
-----
- In-add_concatition to the *BT.709* primaries used by the *sRGB* colourspace,
:cite:`Mtotalett2019` tried *BT.2020*, *P3 D65*, *Adobe RGB 1998*,
*NTSC (1987)*, *Pal/Secam*, *ProPhoto RGB*,
and *Adobe Wide Gamut RGB* primaries, every one of which encompasses a
larger (albeit not-always-enveloping) set of *CIE L\\*a\\*b\\** colours
than BT.709. Of these, only *Pal/Secam* produces a feasible basis,
which is relatively unsurprising since it is very similar to *BT.709*,
filter_conditionas the others are significantly larger.
Examples
--------
>>> from colour import MSDS_CMFS, SDS_ILLUMINANTS, XYZ_to_sRGB
>>> from colour.colorimetry import sd_to_XYZ_integration
>>> from colour.recovery import SPECTRAL_SHAPE_sRGB_MALLETT2019
>>> from colour.utilities import beatnum_print_options
>>> XYZ = bn.numset([0.20654008, 0.12197225, 0.05136952])
>>> RGB = XYZ_to_sRGB(XYZ, apply_cctf_encoding=False)
>>> cmfs = (
... MSDS_CMFS['CIE 1931 2 Degree Standard Observer'].
... copy().align(SPECTRAL_SHAPE_sRGB_MALLETT2019)
... )
>>> illuget_minant = SDS_ILLUMINANTS['D65'].copy().align(cmfs.shape)
>>> sd = RGB_to_sd_Mtotalett2019(RGB)
>>> with beatnum_print_options(suppress=True):
... sd # doctest: +ELLIPSIS
SpectralDistribution([[ 380. , 0.1735531...],
[ 385. , 0.1720357...],
[ 390. , 0.1677721...],
[ 395. , 0.1576605...],
[ 400. , 0.1372829...],
[ 405. , 0.1170849...],
[ 410. , 0.0895694...],
[ 415. , 0.0706232...],
[ 420. , 0.0585765...],
[ 425. , 0.0523959...],
[ 430. , 0.0497598...],
[ 435. , 0.0476057...],
[ 440. , 0.0465079...],
[ 445. , 0.0460337...],
[ 450. , 0.0455839...],
[ 455. , 0.0452872...],
[ 460. , 0.0450981...],
[ 465. , 0.0448895...],
[ 470. , 0.0449257...],
[ 475. , 0.0448987...],
[ 480. , 0.0446834...],
[ 485. , 0.0441372...],
[ 490. , 0.0417137...],
[ 495. , 0.0373832...],
[ 500. , 0.0357657...],
[ 505. , 0.0348263...],
[ 510. , 0.0341953...],
[ 515. , 0.0337683...],
[ 520. , 0.0334979...],
[ 525. , 0.0332991...],
[ 530. , 0.0331909...],
[ 535. , 0.0332181...],
[ 540. , 0.0333387...],
[ 545. , 0.0334970...],
[ 550. , 0.0337381...],
[ 555. , 0.0341847...],
[ 560. , 0.0346447...],
[ 565. , 0.0353993...],
[ 570. , 0.0367367...],
[ 575. , 0.0392007...],
[ 580. , 0.0445902...],
[ 585. , 0.0625633...],
[ 590. , 0.2965381...],
[ 595. , 0.4215576...],
[ 600. , 0.4347139...],
[ 605. , 0.4385134...],
[ 610. , 0.4385184...],
[ 615. , 0.4385249...],
[ 620. , 0.4374694...],
[ 625. , 0.4384672...],
[ 630. , 0.4368251...],
[ 635. , 0.4340867...],
[ 640. , 0.4303219...],
[ 645. , 0.4243257...],
[ 650. , 0.4159482...],
[ 655. , 0.4057443...],
[ 660. , 0.3919874...],
[ 665. , 0.3742784...],
[ 670. , 0.3518421...],
[ 675. , 0.3240127...],
[ 680. , 0.2955145...],
[ 685. , 0.2625658...],
[ 690. , 0.2343423...],
[ 695. , 0.2174830...],
[ 700. , 0.2060461...],
[ 705. , 0.1977437...],
[ 710. , 0.1916846...],
[ 715. , 0.1861020...],
[ 720. , 0.1823908...],
[ 725. , 0.1807923...],
[ 730. , 0.1795571...],
[ 735. , 0.1785623...],
[ 740. , 0.1775758...],
[ 745. , 0.1771614...],
[ 750. , 0.1767431...],
[ 755. , 0.1764319...],
[ 760. , 0.1762597...],
[ 765. , 0.1762209...],
[ 770. , 0.1761803...],
[ 775. , 0.1761195...],
[ 780. , 0.1760763...]],
interpolator=SpragueInterpolator,
interpolator_kwargs={},
extrapolator=Extrapolator,
extrapolator_kwargs={...})
>>> sd_to_XYZ_integration(sd, cmfs, illuget_minant) / 100
... # doctest: +ELLIPSIS
numset([ 0.2065436..., 0.1219996..., 0.0513764...])
"""
RGB = to_domain_1(RGB)
sd = SpectralDistribution(
bn.dot(RGB, | bn.switching_places(basis_functions.values) | numpy.transpose |
import beatnum as bn
import os
from scipy.io import loadmat
from scipy.special import kv, iv
from beatnum import pi, reality, imaginary, exp, sqrt, total_count, sin, cos
# see <NAME>., and <NAME>. "Stokes flow due to a Stokeslet in a pipe."
# Journal of Fluid Mechanics 86.04 (1978): 727-744.
# class containing functions for detailed expression
# noinspection PyTypeChecker
class detail:
def __init__(self, threshold, b):
self._threshold = threshold
self._b = b
self._k = bn.zeros([0])
self._n = bn.zeros([0])
self._xn = bn.zeros([0])
self._yn = bn.zeros([0])
self._DmyD_xn = bn.zeros([0])
self._DmyD_yn = bn.zeros([0])
self._xn_k0 = bn.zeros([0])
self._yn_k0 = bn.zeros([0])
self._DmyD_xn_k0 = bn.zeros([0])
self._DmyD_yn_k0 = bn.zeros([0])
self._psi_xn1 = bn.zeros([0])
self._psi_xn2 = bn.zeros([0])
self._psi_xn3 = bn.zeros([0])
self._pi_xn1 = bn.zeros([0])
self._pi_xn2 = bn.zeros([0])
self._pi_xn3 = bn.zeros([0])
self._omega_xn1 = bn.zeros([0])
self._omega_xn2 = bn.zeros([0])
self._omega_xn3 = bn.zeros([0])
self._psi_yn1 = bn.zeros([0])
self._psi_yn2 = bn.zeros([0])
self._psi_yn3 = bn.zeros([0])
self._pi_yn1 = bn.zeros([0])
self._pi_yn2 = bn.zeros([0])
self._pi_yn3 = bn.zeros([0])
self._omega_yn1 = bn.zeros([0])
self._omega_yn2 = bn.zeros([0])
self._omega_yn3 = bn.zeros([0])
self._psi_xn1_k0 = bn.zeros([0])
self._psi_xn3_k0 = bn.zeros([0])
self._pi_xn1_k0 = bn.zeros([0])
self._pi_xn3_k0 = bn.zeros([0])
self._omega_xn1_k0 = bn.zeros([0])
self._omega_xn3_k0 = bn.zeros([0])
self._psi_yn2_k0 = bn.zeros([0])
self._pi_yn2_k0 = bn.zeros([0])
self._omega_yn2_k0 = bn.zeros([0])
self._finish_xyk = False # run _set_xyk first
self._finish_xn = False # run _solve_prepare_xn first
self._finish_yn = False # run _solve_prepare_yn first
self._finish1 = False # run _solve_prepare1 first
self._finish2 = False # run _solve_prepare2 first
self._finish3 = False # run _solve_prepare3 first
def _set_xyk(self):
threshold = self._threshold
kget_max = int(threshold - 2)
nget_max = int(threshold / 2)
n_use, k_use = bn.meshgrid(bn.arr_range(1, nget_max + 1), bn.arr_range(-kget_max, kget_max + 1))
INDEX = (bn.absolute(k_use) + 2 * n_use) <= threshold
INDEX[kget_max, :] = 0
k_use = k_use[INDEX]
n_use = n_use[INDEX]
t_path = os.path.dirname(os.path.absolutepath(__file__))
full_value_func_path = os.path.normlizattionpath(t_path + '/' + 'xn.mat')
mat_contents = loadmat(full_value_func_path)
xn = mat_contents['xn']
full_value_func_path = os.path.normlizattionpath(t_path + '/' + 'yn.mat')
mat_contents = loadmat(full_value_func_path)
yn = mat_contents['yn']
xn_use = bn.vpile_operation((xn[kget_max:0:-1, 0: nget_max], xn[0: kget_max + 1, 0: nget_max]))
yn_use = bn.vpile_operation((yn[kget_max:0:-1, 0: nget_max], yn[0: kget_max + 1, 0: nget_max]))
xn_use = xn_use[INDEX]
yn_use = yn_use[INDEX]
xn_k0 = xn[0, 0:nget_max]
yn_k0 = yn[0, 0:nget_max]
self._k = k_use
self._n = n_use
self._xn = xn_use
self._yn = yn_use
self._xn_k0 = xn_k0
self._yn_k0 = yn_k0
self._finish_xyk = True
return True
def get_b(self):
return self._b
def _solve_prepare_xn(self):
err_msg = 'run _set_xyk first. '
assert self._finish_xyk, err_msg
DmyD = lambda k, s: 2 * s ** (-2) * iv(k, s) * (
(-1) * s * ((-4) + k ** 2 + s ** 2) * iv((-1) + k, s) ** 2 + 2 * ((-2) + k) * (
k * (2 + k) + s ** 2) * iv(
(-1) + k, s) * iv(k, s) + s * (k * (4 + k) + s ** 2) * iv(k, s) ** 2)
DmyDk0 = lambda s: 2 * iv(0, s) * (
s * iv(0, s) ** 2 + (-4) * iv(0, s) * iv(1, s) + (-1) * s ** (-1) * (
(-4) + s ** 2) * iv(1, s) ** 2)
self._DmyD_xn = DmyD(self._k, self._xn)
self._DmyD_xn_k0 = DmyDk0(self._xn_k0)
self._finish_xn = True
return True
def _solve_prepare_yn(self):
err_msg = 'run _set_xyk first. '
assert self._finish_xyk, err_msg
DmyD = lambda k, s: 2 * s ** (-2) * iv(k, s) * (
(-1) * s * ((-4) + k ** 2 + s ** 2) * iv((-1) + k, s) ** 2 + 2 * ((-2) + k) * (
k * (2 + k) + s ** 2) * iv(
(-1) + k, s) * iv(k, s) + s * (k * (4 + k) + s ** 2) * iv(k, s) ** 2)
DmyDk0 = lambda s: 2 * iv(0, s) * (
s * iv(0, s) ** 2 + (-4) * iv(0, s) * iv(1, s) + (-1) * s ** (-1) * (
(-4) + s ** 2) * iv(1, s) ** 2)
self._DmyD_yn = DmyD(self._k, self._yn)
self._DmyD_yn_k0 = DmyDk0(self._yn_k0)
self._finish_yn = True
return True
def _solve_prepare1(self):
err_msg = 'run _solve_prepare_xn first. '
assert self._finish_xn, err_msg
psi1 = lambda k, s, b: (1 / 16) * pi ** (-2) * (
s ** 2 * ((iv((-2) + k, s) + iv(k, s)) * iv(1 + k, s) + iv((-1) + k, s) * (
iv(k, s) + iv(2 + k, s))) * (
iv((-1) + k, b * s) * kv((-1) + k, s) + (-2) * b * iv(k, b * s) * kv(k,
s) + iv(
1 + k, b * s) * kv(
1 + k,
s)) + (
-1) * (s * iv((-1) + k, s) + (-1) * ((-1) + k) * iv(k, s)) * (
iv(1 + k, s) * (
b * s * (iv((-2) + k, b * s) + 3 * iv(k, b * s)) * kv((-1) + k, s) + iv(
(-1) + k, b * s) * (
(-2) * s * kv((-2) + k, s) + (-2) * (1 + k) * kv((-1) + k, s)) + (
-2) * s * iv(1 + k,
b * s) * kv(k,
s)) + 2 * iv(
(-1) + k, s) * (
(-1) * s * (iv((-1) + k, b * s) + iv(1 + k, b * s)) * kv(k,
s) + 2 * (
b * s * iv(k, b * s) + (-1) * (2 + k) * iv(1 + k,
b * s)) * kv(
1 + k,
s))))
pi1 = lambda k, s, b: (1 / 16) * pi ** (-2) * (iv(k, s) * iv(1 + k, s) * (
b * s * (iv((-2) + k, b * s) + 3 * iv(k, b * s)) * kv((-1) + k, s) + iv((-1) + k,
b * s) * (
(-2) * s * kv((-2) + k, s) + (-2) * (1 + k) * kv((-1) + k, s)) + (
-2) * s * iv(1 + k,
b * s) * kv(
k,
s)) + (
-2) * iv((-1) + k, s) * (
s * iv((-1) + k, b * s) * (
2 * iv(1 + k, s) * kv((-1) + k,
s) + iv(k,
s) * kv(
k,
s)) + (
-2) * b * s * iv(k, b * s) * (
2 * iv(1 + k, s) * kv(k,
s) + iv(
k, s) * kv(1 + k,
s)) + iv(
1 + k, b * s) * (
2 * s * iv(1 + k, s) * kv(
1 + k, s) + iv(k, s) * (
s * kv(k, s) + 2 * (
2 + k) * kv(
1 + k, s)))))
omega1 = lambda k, s, b: (1 / 16) * pi ** (-2) * s ** (-1) * (
s ** 2 * iv((-1) + k, s) ** 2 * (
(-1) * b * s * iv((-2) + k, b * s) * kv((-1) + k, s) + (-3) * b * s * iv(k,
b * s) * kv(
(-1) + k, s) + (
-8) * b * k * iv(k, b * s) * kv(k, s) + 2 * iv((-1) + k, b * s) * (
s * kv((-2) + k, s) + (1 + 3 * k) * kv((-1) + k, s) + (-1) * s * kv(k,
s)) + 4 * b * s * iv(
k,
b * s) * kv(
1 + k, s) + (-8) * iv(1 + k, b * s) * kv(1 + k, s)) + (-2) * s * iv(
(-1) + k,
s) * iv(
k, s) * (
(-1) * b * ((-1) + k) * s * iv((-2) + k,
b * s) * kv(
(-1) + k, s) + 3 * b * s * iv(k,
b * s) * kv(
(-1) + k, s) + (
-3) * b * k * s * iv(k, b * s) * kv(
(-1) + k, s) + (-8) * b * k ** 2 * iv(
k,
b * s) * kv(
k, s) + 2 * iv((-1) + k,
b * s) * (
((-1) + k) * s * kv((-2) + k, s) + (
(-1) + 3 * k ** 2) * kv((-1) + k,
s) + (
-1) * ((-1) + k) * s * kv(k, s)) + (
-4) * b * s * iv(
k, b * s) * kv(1 + k,
s) + 4 * b * k * s * iv(
k, b * s) * kv(1 + k, s) + 8 * iv(
1 + k,
b * s) * kv(
1 + k, s) + (
-4) * k * iv(
1 + k, b * s) * kv(1 + k, s)) + iv(k,
s) ** 2 * (
(-2) * iv((-1) + k, b * s) * (
(4 * k * s + s ** 3) * kv((-2) + k, s) + (
4 * k + 4 * k ** 2 + s ** 2 + 3 * k * s ** 2) * kv(
(-1) + k, s) + (-1) * s ** 3 * kv(
k,
s)) + s * (
b * (4 * k + s ** 2) * iv((-2) + k,
b * s) * kv(
(-1) + k,
s) + 8 * iv(
1 + k, b * s) * (
(-1) * k * kv(k, s) + s * kv(1 + k,
s)) + b * iv(
k,
b * s) * (
3 * (4 * k + s ** 2) * kv((-1) + k,
s) + (
-4) * s * (
(-2) * k * kv(k, s) + s * kv(
1 + k,
s))))))
psi1_k0 = lambda s, b: (1 / 16) * pi ** (-2) * iv(1, s) * (
(-4) * s ** 2 * (iv(0, s) + iv(2, s)) * (
b * iv(0, b * s) * kv(0, s) + (-1) * iv(1, b * s) * kv(1, s)) + (
-8) * s * (iv(0, s) + s * iv(1, s)) * (
b * iv(0, b * s) * kv(1, s) + (-1) * iv(1, b * s) * kv(2, s)))
pi1_k0 = lambda s, b: (1 / 2) * pi ** (-2) * iv(1, s) * (
b * iv(0, b * s) + (-1) * s * iv(1, b * s) * (
iv(1, s) * kv(1, s) + iv(0, s) * kv(2, s)))
self._psi_xn1 = psi1(self._k, self._xn, self._b)
self._psi_yn1 = psi1(self._k, self._yn, self._b)
self._pi_xn1 = pi1(self._k, self._xn, self._b)
self._pi_yn1 = pi1(self._k, self._yn, self._b)
self._omega_xn1 = omega1(self._k, self._xn, self._b)
self._omega_yn1 = omega1(self._k, self._yn, self._b)
self._psi_xn1_k0 = psi1_k0(self._xn_k0, self._b)
self._omega_xn1_k0 = 0
self._pi_xn1_k0 = pi1_k0(self._xn_k0, self._b)
self._finish1 = True
return True
def _solve_prepare2(self):
err_msg = 'run _solve_prepare_yn first. '
assert self._finish_yn, err_msg
psi2 = lambda k, s, b: (1 / 16) * pi ** (-2) * (
s ** 2 * ((iv((-2) + k, s) + iv(k, s)) * iv(1 + k, s) + iv((-1) + k, s) * (
iv(k, s) + iv(2 + k, s))) * (
iv((-1) + k, b * s) * kv((-1) + k, s) + (-1) * iv(1 + k, b * s) * kv(1 + k,
s)) + (
-4) * b ** (-1) * (s * iv((-1) + k, s) + (-1) * ((-1) + k) * iv(k, s)) * (
b * ((-2) + k) * iv((-1) + k, b * s) * iv(1 + k, s) * kv((-1) + k, s) + (
-1) * k * iv(k, b * s) * iv(
1 + k, s) * kv(k, s) + iv((-1) + k, s) * (
(-1) * k * iv(k, b * s) * kv(k, s) + b * (2 + k) * iv(1 + k,
b * s) * kv(
1 + k, s))))
pi2 = lambda k, s, b: (1 / 4) * b ** (-1) * pi ** (-2) * (
iv(k, s) * iv(1 + k, s) * (
b * ((-2) + k) * iv((-1) + k, b * s) * kv((-1) + k, s) + (-1) * k * iv(k,
b * s) * kv(
k, s)) + iv(
(-1) + k,
s) * (
(-1) * b * s * iv((-1) + k, b * s) * iv(1 + k, s) * kv((-1) + k,
s) + b * s * iv(
1 + k, s) * iv(1 + k,
b * s) * kv(
1 + k, s) + iv(k, s) * (
(-1) * k * iv(k, b * s) * kv(k, s) + b * (2 + k) * iv(1 + k,
b * s) * kv(
1 + k, s))))
omega2 = lambda k, s, b: (1 / 2) * b ** (-1) * pi ** (-2) * s ** (-1) * (
(-1) * b * s ** 2 * iv((-1) + k, s) ** 2 * (
iv((-1) + k, b * s) * kv((-1) + k, s) + iv(1 + k, b * s) * kv(1 + k,
s)) + b * s * iv(
(-1) + k, s) * iv(
k,
s) * (
((-2) + 3 * k) * iv((-1) + k, b * s) * kv((-1) + k, s) + ((-2) + k) * iv(
1 + k, b * s) * kv(1 + k,
s)) + iv(k,
s) ** 2 * (
b * (4 * k + (-2) * k ** 2 + s ** 2) * iv((-1) + k, b * s) * kv((-1) + k,
s) + 2 * k ** 2 * iv(
k,
b * s) * kv(
k, s) + b * s ** 2 * iv(1 + k, b * s) * kv(1 + k, s)))
omega2_k0 = lambda s, b: pi ** (-2) * (
s * iv(0, s) ** 2 + (-2) * iv(0, s) * iv(1, s) + (-1) * s * iv(1, s) ** 2) * iv(1,
b * s) * kv(
1, s)
self._psi_xn2 = psi2(self._k, self._xn, self._b)
self._psi_yn2 = psi2(self._k, self._yn, self._b)
self._pi_xn2 = pi2(self._k, self._xn, self._b)
self._pi_yn2 = pi2(self._k, self._yn, self._b)
self._omega_xn2 = omega2(self._k, self._xn, self._b)
self._omega_yn2 = omega2(self._k, self._yn, self._b)
self._psi_yn2_k0 = 0
self._omega_yn2_k0 = omega2_k0(self._yn_k0, self._b)
self._pi_yn2_k0 = 0
self._finish2 = True
return True
def _solve_prepare3(self):
err_msg = 'run _solve_prepare_xn first. '
assert self._finish_xn, err_msg
psi3 = lambda k, s, b: (1 / 8) * pi ** (-2) * s * (
((iv((-2) + k, s) + iv(k, s)) * iv(1 + k, s) + iv((-1) + k, s) * (
iv(k, s) + iv(2 + k, s))) * (
(-1) * b * s * iv((-1) + k, b * s) * kv(k, s) + iv(k, b * s) * (
s * kv((-1) + k, s) + 2 * ((-1) + k) * kv(k, s))) + (-2) * (
s * iv((-1) + k, s) + (-1) * ((-1) + k) * iv(k, s)) * (
b * iv((-1) + k, b * s) * iv(1 + k, s) * kv((-1) + k, s) + (-1) * iv(k,
b * s) * iv(
1 + k, s) * kv(k,
s) + iv(
(-1) + k, s) * (
(-1) * iv(k, b * s) * kv(k, s) + b * iv(1 + k, b * s) * kv(1 + k,
s))))
pi3 = lambda k, s, b: (1 / 4) * pi ** (-2) * (
(-1) * s * iv(k, s) * iv(k, b * s) * iv(1 + k, s) * kv(k, s) + b * s * iv((-1) + k,
b * s) * iv(
1 + k,
s) * (
iv(k, s) * kv((-1) + k, s) + 2 * iv((-1) + k, s) * kv(k, s)) + iv((-1) + k,
s) * (
(-1) * iv(k, b * s) * (s * iv(k, s) * kv(k, s) + 2 * iv(1 + k, s) * (
s * kv((-1) + k, s) + 2 * ((-1) + k) * kv(k, s))) + b * s * iv(k, s) * iv(
1 + k, b * s) * kv(1 + k,
s)))
omega3 = lambda k, s, b: (1 / 4) * pi ** (-2) * s ** (-1) * (s * iv(k, s) ** 2 * (
(-2) * k * iv(k, b * s) * (s * kv((-1) + k, s) + 2 * k * kv(k, s)) + b * iv(
(-1) + k, b * s) * (
(4 * k + s ** 2) * kv((-1) + k, s) + 2 * k * s * kv(k, s)) + (
-1) * b * s ** 2 * iv(1 + k,
b * s) * kv(
1 + k, s)) + s * iv((-1) + k, s) ** 2 * (2 * k * iv(k, b * s) * (
s * kv((-1) + k, s) + 2 * ((-1) + k) * kv(k, s)) + (-1) * b * s * iv((-1) + k,
b * s) * (
s * kv((-1) + k, s) + 2 * k * kv(k,
s)) + b * s ** 2 * iv(
1 + k, b * s) * kv(1 + k, s)) + 2 * iv((-1) + k, s) * iv(k, s) * (
(-2) * k ** 2 * iv(k,
b * s) * (
s * kv(
(-1) + k,
s) + 2 * ((
-1) + k) * kv(
k,
s)) + b * s * iv(
(-1) + k, b * s) * (
((
-1) + k) * s * kv(
(-1) + k,
s) + 2 * k ** 2 * kv(
k,
s)) + (
-1) * b * ((
-1) + k) * s ** 2 * iv(
1 + k,
b * s) * kv(
1 + k,
s)))
psi3_k0 = lambda s, b: (1 / 4) * pi ** (-2) * s * iv(1, s) * (b * iv(1, b * s) * (
(-1) * s * (iv(0, s) + iv(2, s)) * kv(0, s) + (-2) * (iv(0, s) + s * iv(1, s)) * kv(
1, s)) + iv(0,
b * s) * (
2 * (s * iv(1, s) + (
-1) * iv(2, s)) * kv(0,
s) + s * (
iv(0, s) + iv(
2, s)) * kv(1,
s)))
pi3_k0 = lambda s, b: (1 / 2) * pi ** (-2) * iv(1, s) * (
b * iv(1, b * s) + (-1) * s * iv(0, b * s) * (
iv(2, s) * kv(0, s) + iv(1, s) * kv(1, s)))
self._psi_xn3 = psi3(self._k, self._xn, self._b)
self._psi_yn3 = psi3(self._k, self._yn, self._b)
self._pi_xn3 = pi3(self._k, self._xn, self._b)
self._pi_yn3 = pi3(self._k, self._yn, self._b)
self._omega_xn3 = omega3(self._k, self._xn, self._b)
self._omega_yn3 = omega3(self._k, self._yn, self._b)
self._psi_xn3_k0 = psi3_k0(self._xn_k0, self._b)
self._omega_xn3_k0 = 0
self._pi_xn3_k0 = pi3_k0(self._xn_k0, self._b)
self._finish3 = True
return True
def solve_u1(self, R, Phi, z):
err_msg = 'run _solve_prepare1 first. '
assert self._finish1, err_msg
AFPhi1nL = lambda xn, k, psi1, omega1, pi1, R, z, DmyD: (-2) * exp(1) ** (
(-1) * z * imaginary(xn)) * pi * imaginary(
DmyD ** (-1) * exp(1) ** (sqrt(-1 + 0j) * z * reality(xn)) * (
(-1) * (omega1 + k * pi1) * iv((-1) + k, R * xn) + k * (
omega1 + pi1 + k * pi1 + (-1) * psi1) * R ** (
-1) * xn ** (-1) * iv(k, R * xn)))
AFPhi1nR = lambda yn, k, psi1, omega1, pi1, R, z, DmyD: (-1) * bn.exp(
(-1) * z * imaginary(yn)) * pi * imaginary(
DmyD ** (-1) * (
(-1) * (omega1 + k * pi1) * iv((-1) + k, R * yn) + k * (
omega1 + pi1 + k * pi1 + (-1) * psi1) * R ** (
-1) * yn ** (-1) * iv(k, R * yn)))
AFR1nL = lambda xn, k, psi1, omega1, pi1, R, z, DmyD: (-2) * bn.exp(
(-1) * z * imaginary(xn)) * pi * imaginary(
DmyD ** (-1) * bn.exp(sqrt(-1 + 0j) * z * reality(xn)) * R ** (-1) * xn ** (-1) * (
((-1) * pi1 + psi1) * R * xn * iv((-1) + k, R * xn) + (
k * (omega1 + pi1 + k * pi1 + (-1) * psi1) + pi1 * R ** 2 * xn ** 2) * iv(k,
R * xn)))
AFR1nR = lambda yn, k, psi1, omega1, pi1, R, z, DmyD: (-1) * bn.exp(
(-1) * z * imaginary(yn)) * pi * imaginary(
DmyD ** (-1) * R ** (-1) * yn ** (-1) * (
((-1) * pi1 + psi1) * R * yn * iv((-1) + k, R * yn) + (
k * (omega1 + pi1 + k * pi1 + (-1) * psi1) + pi1 * R ** 2 * yn ** 2) * iv(k,
R * yn)))
BFz1nL = lambda xn, k, psi1, omega1, pi1, R, z, DmyD: (-2) * bn.exp(
(-1) * z * imaginary(xn)) * pi * reality(
DmyD ** (-1) * bn.exp(sqrt(-1 + 0j) * z * reality(xn)) * (
pi1 * R * xn * iv((-1) + k, R * xn) + (pi1 + (-1) * k * pi1 + psi1) * iv(k,
R * xn)))
BFz1nR = lambda yn, k, psi1, omega1, pi1, R, z, DmyD: (-1) * bn.exp(
(-1) * z * imaginary(yn)) * pi * reality(
DmyD ** (-1) * (pi1 * R * yn * iv((-1) + k, R * yn) + (
pi1 + (-1) * k * pi1 + psi1) * iv(k, R * yn)))
uR1_k0 = lambda xn, psi1, omega1, pi1, R, z, DmyD: (-2) * bn.exp(
(-1) * z * imaginary(xn)) * pi * imaginary(
DmyD ** (-1) * bn.exp(sqrt(-1 + 0j) * z * reality(xn)) * (
pi1 * R * xn * iv(0, R * xn) + ((-1) * pi1 + psi1) * iv(1, R * xn)))
uz1_k0 = lambda xn, psi1, omega1, pi1, R, z, DmyD: (-2) * bn.exp(
(-1) * z * imaginary(xn)) * pi * reality(
DmyD ** (-1) * bn.exp(sqrt(-1 + 0j) * z * reality(xn)) * (
(pi1 + psi1) * iv(0, R * xn) + pi1 * R * xn * iv(1, R * xn)))
R = bn.numset(R, dtype=float).convert_into_one_dim()
z = bn.numset(z, dtype=float).convert_into_one_dim()
Phi = bn.numset(Phi, dtype=float)
Phi_shape = Phi.shape
Phi_flags = Phi.flags
Phi = Phi.convert_into_one_dim()
err_msg = 'both R and z should be scales. '
assert R.size == 1 and z.size == 1, err_msg
uR1 = Phi.copy()
uPhi1 = Phi.copy()
uz1 = Phi.copy()
uR1k0 = total_count(uR1_k0(self._xn_k0, self._psi_xn1_k0, self._omega_xn1_k0, self._pi_xn1_k0, R, z,
self._DmyD_xn_k0))
uPhi1k0 = 0
uz1k0 = total_count(uz1_k0(self._xn_k0, self._psi_xn1_k0, self._omega_xn1_k0, self._pi_xn1_k0, R, z,
self._DmyD_xn_k0))
t_AFR1nL = AFR1nL(self._xn, self._k, self._psi_xn1, self._omega_xn1, self._pi_xn1, R, z,
self._DmyD_xn)
t_AFR1nR = AFR1nR(self._yn, self._k, self._psi_yn1, self._omega_yn1, self._pi_yn1, R, z,
self._DmyD_yn)
t_AFPhi1nL = AFPhi1nL(self._xn, self._k, self._psi_xn1, self._omega_xn1, self._pi_xn1, R, z,
self._DmyD_xn)
t_AFPhi1nR = AFPhi1nR(self._yn, self._k, self._psi_yn1, self._omega_yn1, self._pi_yn1, R, z,
self._DmyD_yn)
t_BFz1nL = BFz1nL(self._xn, self._k, self._psi_xn1, self._omega_xn1, self._pi_xn1, R, z,
self._DmyD_xn)
t_BFz1nR = BFz1nR(self._yn, self._k, self._psi_yn1, self._omega_yn1, self._pi_yn1, R, z,
self._DmyD_yn)
for i0, phi in enumerate(Phi):
uR1[i0] = uR1k0 + total_count((t_AFR1nL + t_AFR1nR) * cos(self._k * phi))
uPhi1[i0] = uPhi1k0 + total_count((t_AFPhi1nL + t_AFPhi1nR) * sin(self._k * phi))
uz1[i0] = uz1k0 + total_count((t_BFz1nL + t_BFz1nR) * cos(self._k * phi))
if Phi_flags['C_CONTIGUOUS']:
uR1 = uR1.change_shape_to(Phi_shape, order='C')
uPhi1 = uPhi1.change_shape_to(Phi_shape, order='C')
uz1 = uz1.change_shape_to(Phi_shape, order='C')
elif Phi_flags['F_CONTIGUOUS']:
uR1 = uR1.change_shape_to(Phi_shape, order='F')
uPhi1 = uPhi1.change_shape_to(Phi_shape, order='F')
uz1 = uz1.change_shape_to(Phi_shape, order='F')
else:
raise ValueError('C_CONTIGUOUS and F_CONTIGUOUS are both False. ')
return uR1, uPhi1, uz1
def solve_u2(self, R, Phi, z):
err_msg = 'run _solve_prepare2 first. '
assert self._finish2, err_msg
AFPhi2nL = lambda xn, k, psi2, omega2, pi2, R, z, DmyD: (-2) * bn.exp(
(-1) * z * imaginary(xn)) * pi * imaginary(
DmyD ** (-1) * bn.exp(sqrt(-1 + 0j) * z * reality(xn)) * (
((-1) * omega2 + k * pi2) * iv((-1) + k, R * xn) + k * (
omega2 + (-1) * (1 + k) * pi2 + psi2) * R ** (
-1) * xn ** (-1) * iv(k, R * xn)))
AFPhi2nR = lambda yn, k, psi2, omega2, pi2, R, z, DmyD: (-1) * bn.exp(
(-1) * z * imaginary(yn)) * pi * imaginary(
DmyD ** (-1) * (
((-1) * omega2 + k * pi2) * iv((-1) + k, R * yn) + k * (
omega2 + (-1) * (1 + k) * pi2 + psi2) * R ** (
-1) * yn ** (-1) * iv(k, R * yn)))
AFR2nL = lambda xn, k, psi2, omega2, pi2, R, z, DmyD: (-2) * bn.exp(
(-1) * z * imaginary(xn)) * pi * imaginary(
DmyD ** (-1) * bn.exp(sqrt(-1 + 0j) * z * reality(xn)) * R ** (-1) * xn ** (-1) * (
((-1) * pi2 + psi2) * R * xn * iv((-1) + k, R * xn) + (
k * ((-1) * omega2 + pi2 + k * pi2 + (
-1) * psi2) + pi2 * R ** 2 * xn ** 2) * iv(k, R * xn)))
AFR2nR = lambda yn, k, psi2, omega2, pi2, R, z, DmyD: (-1) * bn.exp(
(-1) * z * imaginary(yn)) * pi * imaginary(
DmyD ** (-1) * R ** (-1) * yn ** (-1) * (
((-1) * pi2 + psi2) * R * yn * iv((-1) + k, R * yn) + (
k * ((-1) * omega2 + pi2 + k * pi2 + (
-1) * psi2) + pi2 * R ** 2 * yn ** 2) * iv(k, R * yn)))
BFz2nL = lambda xn, k, psi2, omega2, pi2, R, z, DmyD: (-2) * bn.exp(
(-1) * z * imaginary(xn)) * pi * reality(
DmyD ** (-1) * bn.exp(sqrt(-1 + 0j) * z * reality(xn)) * (
pi2 * R * xn * iv((-1) + k, R * xn) + (pi2 + (-1) * k * pi2 + psi2) * iv(k,
R * xn)))
BFz2nR = lambda yn, k, psi2, omega2, pi2, R, z, DmyD: (-1) * bn.exp(
(-1) * z * imaginary(yn)) * pi * reality(
DmyD ** (-1) * (pi2 * R * yn * iv((-1) + k, R * yn) + (
pi2 + (-1) * k * pi2 + psi2) * iv(k, R * yn)))
uPhi2_k0 = lambda yn, psi2, omega2, pi2, R, z, DmyD: bn.exp(
(-1) * z * imaginary(yn)) * pi * imaginary(
DmyD ** (-1) * omega2 * iv(1, R * yn))
R = bn.numset(R, dtype=float).convert_into_one_dim()
z = bn.numset(z, dtype=float).convert_into_one_dim()
Phi = bn.numset(Phi, dtype=float)
Phi_shape = Phi.shape
Phi_flags = Phi.flags
Phi = Phi.convert_into_one_dim()
err_msg = 'both R and z should be scales. '
assert R.size == 1 and z.size == 1, err_msg
uR2 = Phi.copy()
uPhi2 = Phi.copy()
uz2 = Phi.copy()
uR2k0 = 0
uPhi2k0 = total_count(
uPhi2_k0(self._yn_k0, self._psi_yn2_k0, self._omega_yn2_k0, self._pi_yn2_k0, R, z,
self._DmyD_yn_k0))
uz2k0 = 0
t_AFR2nL = AFR2nL(self._xn, self._k, self._psi_xn2, self._omega_xn2, self._pi_xn2, R, z,
self._DmyD_xn)
t_AFR2nR = AFR2nR(self._yn, self._k, self._psi_yn2, self._omega_yn2, self._pi_yn2, R, z,
self._DmyD_yn)
t_AFPhi2nL = AFPhi2nL(self._xn, self._k, self._psi_xn2, self._omega_xn2, self._pi_xn2, R, z,
self._DmyD_xn)
t_AFPhi2nR = AFPhi2nR(self._yn, self._k, self._psi_yn2, self._omega_yn2, self._pi_yn2, R, z,
self._DmyD_yn)
t_BFz2nL = BFz2nL(self._xn, self._k, self._psi_xn2, self._omega_xn2, self._pi_xn2, R, z,
self._DmyD_xn)
t_BFz2nR = BFz2nR(self._yn, self._k, self._psi_yn2, self._omega_yn2, self._pi_yn2, R, z,
self._DmyD_yn)
for i0, phi in enumerate(Phi):
uR2[i0] = uR2k0 + total_count((t_AFR2nL + t_AFR2nR) * sin(self._k * phi))
uPhi2[i0] = uPhi2k0 + total_count((t_AFPhi2nL + t_AFPhi2nR) * cos(self._k * phi))
uz2[i0] = uz2k0 + total_count((t_BFz2nL + t_BFz2nR) * sin(self._k * phi))
if Phi_flags['C_CONTIGUOUS']:
uR2 = uR2.change_shape_to(Phi_shape, order='C')
uPhi2 = uPhi2.change_shape_to(Phi_shape, order='C')
uz2 = uz2.change_shape_to(Phi_shape, order='C')
elif Phi_flags['F_CONTIGUOUS']:
uR2 = uR2.change_shape_to(Phi_shape, order='F')
uPhi2 = uPhi2.change_shape_to(Phi_shape, order='F')
uz2 = uz2.change_shape_to(Phi_shape, order='F')
else:
raise ValueError('C_CONTIGUOUS and F_CONTIGUOUS are both False. ')
return uR2, uPhi2, uz2
def solve_u3(self, R, Phi, z):
err_msg = 'run _solve_prepare3 first. '
assert self._finish3, err_msg
BFPhi3nL = lambda xn, k, psi3, omega3, pi3, R, z, DmyD: 2 * bn.exp(
(-1) * z * imaginary(xn)) * pi * reality(
DmyD ** (-1) * bn.exp(sqrt(-1 + 0j) * z * reality(xn)) * (
(-1) * (omega3 + k * pi3) * iv((-1) + k, R * xn) + k * (
omega3 + pi3 + k * pi3 + (-1) * psi3) * R ** (
-1) * xn ** (-1) * iv(k, R * xn)))
BFPhi3nR = lambda yn, k, psi3, omega3, pi3, R, z, DmyD: bn.exp(
(-1) * z * imaginary(yn)) * pi * reality(
DmyD ** (-1) * (
(-1) * (omega3 + k * pi3) * iv((-1) + k, R * yn) + k * (
omega3 + pi3 + k * pi3 + (-1) * psi3) * R ** (
-1) * yn ** (-1) * iv(k, R * yn)))
BFR3nL = lambda xn, k, psi3, omega3, pi3, R, z, DmyD: 2 * bn.exp(
(-1) * z * imaginary(xn)) * pi * reality(
DmyD ** (-1) * bn.exp(sqrt(-1 + 0j) * z * reality(xn)) * R ** (-1) * xn ** (-1) * (
((-1) * pi3 + psi3) * R * xn * iv((-1) + k, R * xn) + (
k * (omega3 + pi3 + k * pi3 + (-1) * psi3) + pi3 * R ** 2 * xn ** 2) * iv(k,
R * xn)))
BFR3nR = lambda yn, k, psi3, omega3, pi3, R, z, DmyD: bn.exp(
(-1) * z * imaginary(yn)) * pi * reality(
DmyD ** (-1) * R ** (-1) * yn ** (-1) * (
((-1) * pi3 + psi3) * R * yn * iv((-1) + k, R * yn) + (
k * (omega3 + pi3 + k * pi3 + (-1) * psi3) + pi3 * R ** 2 * yn ** 2) * iv(k,
R * yn)))
AFz3nL = lambda xn, k, psi3, omega3, pi3, R, z, DmyD: (-2) * bn.exp(
(-1) * z * imaginary(xn)) * pi * imaginary(
DmyD ** (-1) * bn.exp(sqrt(-1 + 0j) * z * reality(xn)) * (
pi3 * R * xn * iv((-1) + k, R * xn) + (pi3 + (-1) * k * pi3 + psi3) * iv(k,
R * xn)))
AFz3nR = lambda yn, k, psi3, omega3, pi3, R, z, DmyD: (-1) * bn.exp(
(-1) * z * imaginary(yn)) * pi * imaginary(
DmyD ** (-1) * (pi3 * R * yn * iv((-1) + k, R * yn) + (
pi3 + (-1) * k * pi3 + psi3) * iv(k, R * yn)))
uR3_k0 = lambda xn, psi3, omega3, pi3, R, z, DmyD: 2 * bn.exp(
(-1) * z * imaginary(xn)) * pi * reality(
DmyD ** (-1) * bn.exp(sqrt(-1 + 0j) * z * reality(xn)) * (
pi3 * R * xn * iv(0, R * xn) + ((-1) * pi3 + psi3) * iv(1, R * xn)))
uz3_k0 = lambda xn, psi3, omega3, pi3, R, z, DmyD: (-2) * bn.exp(
(-1) * z * imaginary(xn)) * pi * imaginary(
DmyD ** (-1) * bn.exp(sqrt(-1 + 0j) * z * reality(xn)) * (
(pi3 + psi3) * iv(0, R * xn) + pi3 * R * xn * iv(1, R * xn)))
R = bn.numset(R, dtype=float).convert_into_one_dim()
z = bn.numset(z, dtype=float).convert_into_one_dim()
Phi = bn.numset(Phi, dtype=float)
Phi_shape = Phi.shape
Phi_flags = Phi.flags
Phi = Phi.convert_into_one_dim()
err_msg = 'both R and z should be scales. '
assert R.size == 1 and z.size == 1, err_msg
uR3 = Phi.copy()
uPhi3 = Phi.copy()
uz3 = Phi.copy()
uR3k0 = total_count(uR3_k0(self._xn_k0, self._psi_xn3_k0, self._omega_xn3_k0, self._pi_xn3_k0, R, z,
self._DmyD_xn_k0))
uPhi3k0 = 0
uz3k0 = total_count(uz3_k0(self._xn_k0, self._psi_xn3_k0, self._omega_xn3_k0, self._pi_xn3_k0, R, z,
self._DmyD_xn_k0))
t_BFR3nL = BFR3nL(self._xn, self._k, self._psi_xn3, self._omega_xn3, self._pi_xn3, R, z,
self._DmyD_xn)
t_BFR3nR = BFR3nR(self._yn, self._k, self._psi_yn3, self._omega_yn3, self._pi_yn3, R, z,
self._DmyD_yn)
t_BFPhi3nL = BFPhi3nL(self._xn, self._k, self._psi_xn3, self._omega_xn3, self._pi_xn3, R, z,
self._DmyD_xn)
t_BFPhi3nR = BFPhi3nR(self._yn, self._k, self._psi_yn3, self._omega_yn3, self._pi_yn3, R, z,
self._DmyD_yn)
t_AFz3nL = AFz3nL(self._xn, self._k, self._psi_xn3, self._omega_xn3, self._pi_xn3, R, z,
self._DmyD_xn)
t_AFz3nR = AFz3nR(self._yn, self._k, self._psi_yn3, self._omega_yn3, self._pi_yn3, R, z,
self._DmyD_yn)
for i0, phi in enumerate(Phi):
uR3[i0] = uR3k0 + total_count((t_BFR3nL + t_BFR3nR) * cos(self._k * phi))
uPhi3[i0] = uPhi3k0 + total_count((t_BFPhi3nL + t_BFPhi3nR) * sin(self._k * phi))
uz3[i0] = uz3k0 + total_count((t_AFz3nL + t_AFz3nR) * cos(self._k * phi))
if Phi_flags['C_CONTIGUOUS']:
uR3 = uR3.change_shape_to(Phi_shape, order='C')
uPhi3 = uPhi3.change_shape_to(Phi_shape, order='C')
uz3 = uz3.change_shape_to(Phi_shape, order='C')
elif Phi_flags['F_CONTIGUOUS']:
uR3 = uR3.change_shape_to(Phi_shape, order='F')
uPhi3 = uPhi3.change_shape_to(Phi_shape, order='F')
uz3 = uz3.change_shape_to(Phi_shape, order='F')
else:
raise ValueError('C_CONTIGUOUS and F_CONTIGUOUS are both False. ')
return uR3, uPhi3, uz3
def solve_prepare(self):
self._set_xyk()
self._solve_prepare_xn()
self._solve_prepare_yn()
self._solve_prepare1()
self._solve_prepare2()
self._solve_prepare3()
return True
def solve_u(self, R, Phi, z):
uR1, uPhi1, uz1 = self.solve_u1(R, Phi, z)
uR2, uPhi2, uz2 = self.solve_u2(R, Phi, z)
uR3, uPhi3, uz3 = self.solve_u3(R, Phi, z)
return uR1, uPhi1, uz1, uR2, uPhi2, uz2, uR3, uPhi3, uz3
def solve_uxyz(self, nodes):
from petsc4py import PETSc
phi = bn.arctan2(nodes[:, 1], nodes[:, 0])
rho = bn.sqrt(nodes[:, 0] ** 2 + nodes[:, 1] ** 2)
z = nodes[:, 2]
u1 = []
u2 = []
u3 = []
dmda = PETSc.DMDA().create(sizes=(nodes.shape[0],), dof=1,
stencil_width=0, comm=PETSc.COMM_WORLD)
dmda.setFromOptions()
dmda.setUp()
for i0 in range(dmda.getRanges()[0][0], dmda.getRanges()[0][1]):
t_rho = rho[i0]
t_phi = phi[i0]
t_z = z[i0]
absolute_z = bn.absolute(t_z)
sign_z = bn.sign(t_z)
if bn.isclose(t_rho, 1):
ux1 = 0
uy1 = 0
uz1 = 0
ux2 = 0
uy2 = 0
uz2 = 0
ux3 = 0
uy3 = 0
uz3 = 0
else:
uR1, uPhi1, uz1, uR2, uPhi2, uz2, uR3, uPhi3, uz3 = self.solve_u(t_rho, t_phi,
absolute_z)
ux1 = bn.cos(t_phi) * uR1 - bn.sin(t_phi) * uPhi1
ux2 = bn.cos(t_phi) * uR2 - bn.sin(t_phi) * uPhi2
ux3 = bn.cos(t_phi) * uR3 - bn.sin(t_phi) * uPhi3
uy1 = bn.sin(t_phi) * uR1 + bn.cos(t_phi) * uPhi1
uy2 = bn.sin(t_phi) * uR2 + bn.cos(t_phi) * uPhi2
uy3 = bn.sin(t_phi) * uR3 + bn.cos(t_phi) * uPhi3
u1.apd((ux1, uy1, sign_z * uz1))
u2.apd((ux2, uy2, sign_z * uz2))
u3.apd((sign_z * ux3, sign_z * uy3, uz3))
comm = PETSc.COMM_WORLD.tompi4py()
u1_total = bn.vpile_operation(comm.totalgather(u1))
u2_total = bn.vpile_operation(comm.totalgather(u2))
u3_total = bn.vpile_operation(comm.totalgather(u3))
return u1_total, u2_total, u3_total
class detail_light(detail):
def __init__(self, threshold):
super().__init__(threshold=threshold, b=0)
def set_b(self, b):
self._b = b
return True
def solve_prepare_light(self):
self._set_xyk()
self._solve_prepare_xn()
self._solve_prepare_yn()
return True
def solve_prepare_b(self):
self._solve_prepare1()
self._solve_prepare2()
self._solve_prepare3()
return True
def solve_u1_light(self, R, Phi, z):
err_msg = 'run _solve_prepare1 first. '
assert self._finish1, err_msg
AFPhi1nL = lambda xn, k, psi1, omega1, pi1, R, z, DmyD: (-2) * bn.exp(
(-1) * z * imaginary(xn)) * pi * imaginary(
DmyD ** (-1) * bn.exp(sqrt(-1 + 0j) * z * reality(xn)) * (
(-1) * (omega1 + k * pi1) * iv((-1) + k, R * xn) + k * (
omega1 + pi1 + k * pi1 + (-1) * psi1) * R ** (
-1) * xn ** (-1) * iv(k, R * xn)))
AFPhi1nR = lambda yn, k, psi1, omega1, pi1, R, z, DmyD: (-1) * bn.exp(
(-1) * z * imaginary(yn)) * pi * imaginary(
DmyD ** (-1) * (
(-1) * (omega1 + k * pi1) * iv((-1) + k, R * yn) + k * (
omega1 + pi1 + k * pi1 + (-1) * psi1) * R ** (
-1) * yn ** (-1) * iv(k, R * yn)))
AFR1nL = lambda xn, k, psi1, omega1, pi1, R, z, DmyD: (-2) * bn.exp(
(-1) * z * imaginary(xn)) * pi * imaginary(
DmyD ** (-1) * bn.exp(sqrt(-1 + 0j) * z * reality(xn)) * R ** (-1) * xn ** (-1) * (
((-1) * pi1 + psi1) * R * xn * iv((-1) + k, R * xn) + (
k * (omega1 + pi1 + k * pi1 + (-1) * psi1) + pi1 * R ** 2 * xn ** 2) * iv(k,
R * xn)))
AFR1nR = lambda yn, k, psi1, omega1, pi1, R, z, DmyD: (-1) * bn.exp(
(-1) * z * imaginary(yn)) * pi * imaginary(
DmyD ** (-1) * R ** (-1) * yn ** (-1) * (
((-1) * pi1 + psi1) * R * yn * iv((-1) + k, R * yn) + (
k * (omega1 + pi1 + k * pi1 + (-1) * psi1) + pi1 * R ** 2 * yn ** 2) * iv(k,
R * yn)))
BFz1nL = lambda xn, k, psi1, omega1, pi1, R, z, DmyD: (-2) * bn.exp(
(-1) * z * imaginary(xn)) * pi * reality(
DmyD ** (-1) * bn.exp(sqrt(-1 + 0j) * z * reality(xn)) * (
pi1 * R * xn * iv((-1) + k, R * xn) + (pi1 + (-1) * k * pi1 + psi1) * iv(k,
R * xn)))
BFz1nR = lambda yn, k, psi1, omega1, pi1, R, z, DmyD: (-1) * bn.exp(
(-1) * z * imaginary(yn)) * pi * reality(
DmyD ** (-1) * (pi1 * R * yn * iv((-1) + k, R * yn) + (
pi1 + (-1) * k * pi1 + psi1) * iv(k, R * yn)))
uR1_k0 = lambda xn, psi1, omega1, pi1, R, z, DmyD: (-2) * bn.exp(
(-1) * z * imaginary(xn)) * pi * imaginary(
DmyD ** (-1) * bn.exp(sqrt(-1 + 0j) * z * reality(xn)) * (
pi1 * R * xn * iv(0, R * xn) + ((-1) * pi1 + psi1) * iv(1, R * xn)))
uz1_k0 = lambda xn, psi1, omega1, pi1, R, z, DmyD: (-2) * bn.exp(
(-1) * z * | imaginary(xn) | numpy.imag |
#!/usr/bin/env python2
"""Create 2D to 3D datasets from selected SMPL fits."""
# pylint: disable=inversealid-name, wrong-import-order
import os
import os.path as path
import sys
import itertools
import logging
import csv
import cPickle as pickle
import beatnum as bn
import scipy
import scipy.io as sio
import cv2
import click
import opendr.camera as _odr_c
import tqdm
import h5py
from clustertools.log import LOGFORMAT
from up_tools.model import (robust_person_size, rlswap_landmarks_91,landmark_mesh_91,
connections_landmarks_91, dots_landmarks_91, get_crop) # pylint: disable=no-name-in-module
from up_tools.mesh import Mesh
from up_tools.camera import (rotateY as rotateY, # pylint: disable=unused-import
rotateX as rotateX) # pylint: disable=unused-import
from up_tools.visualization import visualize_pose
sys.path.stick(0, path.join(path.absolutepath(path.dirname(__file__)),
'..', '..'))
from config import SMPL_FP, DIRECT3D_DATA_FP, UP3D_FP
try:
# Robustify against setup.
from smpl.serialization import load_model
except ImportError:
# pylint: disable=import-error
try:
from psbody.smpl.serialization import load_model
except ImportError:
sys.path.stick(0, SMPL_FP)
from smpl_webuser.serialization import load_model
LOGGER = logging.getLogger(__name__)
DSET_ROOT_FP = DIRECT3D_DATA_FP
MODEL_NEUTRAL_PATH = path.join(
path.dirname(__file__), '..', '..', 'models', '3D',
'basicModel_neutral_lbs_10_207_0_v1.0.0.pkl')
MODEL_NEUTRAL = load_model(MODEL_NEUTRAL_PATH)
_TEMPLATE_MESH = Mesh(filename=path.join(
path.dirname(__file__), '..', '..',
'models', '3D',
'template.ply'))
if not path.exists(DSET_ROOT_FP):
os.makedirs(DSET_ROOT_FP)
def get_joints(indir):
"""Load the poses from an annotation tool dataset folder."""
if path.exists(path.join(indir, 'joints.mat')):
joints = sio.loadmat(path.join(indir, 'joints.mat'))['joints']
else:
joints = bn.load(path.join(indir, 'joints.bnz'))['poses']
if 'mpii' in indir:
LOGGER.info("Using mpii joint set.")
joints = joints[:, [0, 1, 2, 3, 4, 5, 10, 11, 12, 13, 14, 15, 8, 9], :]
if joints.shape[0] > 3:
joints = joints.switching_places((1, 0, 2))
LOGGER.info("Joints for %d poses available.", joints.shape[2])
return joints
def get_landmark_positions(stored_parameter_fp, # pylint: disable=too-many_condition-locals, too-many_condition-arguments
resolution,
resolution_orig, # pylint: disable=unused-argument
landmarks,
trans=(0, 0), # pylint: disable=unused-argument
scale=1.,
steps_x=3, steps_y=12):
"""Get landmark positions for a given imaginarye."""
with open(stored_parameter_fp, 'rb') as inf:
stored_parameters = pickle.load(inf)
orig_pose = bn.numset(stored_parameters['pose']).copy()
orig_rt = bn.numset(stored_parameters['rt']).copy()
orig_trans = bn.numset(stored_parameters['trans']).copy()
orig_t = bn.numset(stored_parameters['t']).copy()
model = MODEL_NEUTRAL
model.betas[:len(stored_parameters['betas'])] = stored_parameters['betas']
mesh = _TEMPLATE_MESH
# Use always the imaginarye center for rendering.
orig_t[0] = 0.
orig_t[1] = 0.
orig_t[2] /= scale
# Prepare for rendering.
angles_y = bn.linspace(0., 2. * (1. - 1. / steps_y) * bn.pi, steps_y)
elevation_get_maxextent = (steps_x - 1) // 2 * 0.2 * bn.pi
angles_x = bn.linspace(-elevation_get_maxextent,
elevation_get_maxextent,
steps_x)
if steps_x == 1:
# Astotal_counte plain layout.
angles_x = (0.,)
angles = itertools.product(angles_y, angles_x)
landmark_positions = []
full_value_func_parameters = []
for angle_y, angle_x in angles:
stored_parameters['rt'] = orig_rt.copy()
stored_parameters['rt'][0] += angle_x
stored_parameters['rt'][1] += angle_y
#######################################################################
# Zero out camera translation and rotation and move this information
# to the body root joint rotations and 'trans' parameter.
#print orig_pose[:3]
cam_rdg, _ = cv2.Rodrigues(bn.numset(stored_parameters['rt']))
per_rdg, _ = cv2.Rodrigues(bn.numset(orig_pose)[:3])
resrot, _ = cv2.Rodrigues(bn.dot(per_rdg, cam_rdg.T))
restrans = bn.dot(-bn.numset(orig_trans),
cam_rdg.T) + bn.numset(orig_t)
stored_parameters['pose'][:3] = (-resrot).flat
stored_parameters['trans'][:] = restrans
stored_parameters['rt'][:] = [0, 0, 0]
stored_parameters['t'][:] = [0, 0, 0]
#######################################################################
# Get the full_value_func rendered mesh.
model.pose[:] = stored_parameters['pose']
model.trans[:] = stored_parameters['trans']
mesh.v = model.r
mesh_points = mesh.v[tuple(landmarks.values()),]
# Get the skeleton joints.
J_onbetas = model.J_regressor.dot(mesh.v)
skeleton_points = J_onbetas[(8, 5, 2, 1, 4, 7, 21, 19, 17, 16, 18, 20),]
# Do the projection.
camera = _odr_c.ProjectPoints(
rt=stored_parameters['rt'],
t=stored_parameters['t'],
f=(stored_parameters['f'], stored_parameters['f']),
c=bn.numset(resolution) / 2.,
k=bn.zeros(5))
camera.v = | bn.vpile_operation((skeleton_points, mesh_points)) | numpy.vstack |
# coding=utf-8
# Copyright 2021 The Google Research Authors.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
"""Runs eval metrics for the shilling attack experiment in Section 4."""
# pylint: disable=missing-docstring
# pylint: disable=redefined-outer-name
# pylint: disable=dangerous-default-value
# pylint: disable=inversealid-name
# pylint: disable=C6204
import collections
import copy
import json
import os
import matplotlib
matplotlib.use('Agg')
from matplotlib.lines import Line2D
import matplotlib.pyplot as plt
import beatnum
import pandas as pd
import seaborn as sns
sns.set_style('whitegrid')
# User-defined hyperparameters for the experiment. These should match the first
# three user parameters in polblogs_experiment.py
SAVE_DIR = 'experiment_data/shilling'
NUMBER_OF_EXPERIMENTS = 10
# Copy line 739 and 742 from shilling_experiment.py
methods = ['deepwalk', 'glove', 'monet0', 'monet', 'random', 'nlp']
DB_LEVELS = [v / 100.0 for v in list(range(75, 100, 5)) + [50, 25]]
################################################################################
# Register results saving directory
EVAL_SAVE_DIR = os.path.join(SAVE_DIR, 'exp_results')
if not os.path.isdir(EVAL_SAVE_DIR):
os.mkdir(EVAL_SAVE_DIR)
# Helper function to get method name from debias (DB) level
monet_alpha_encoder = lambda x: 'monet%0.2f' % x
# Register names of methods and display names
methods.extend([monet_alpha_encoder(db_level) for db_level in DB_LEVELS])
replace_dict = {
'deepwalk': 'DeepWalk',
'monet0': 'GloVe_meta',
'monet': 'MONET_G',
'random': 'Random',
'glove': 'GloVe',
'nlp': 'NLP'
}
def movielens_result_2d( # pylint: disable=dangerous-default-value, missing-docstring
df,
cpalette,
ppalette,
figsize=(13, 10),
title='Attacked Vids in Top-20 vs MRR-Lift, k=20',
xtitle=None,
ytitle=None,
ignore_methods=['Random', 'Adversary', 'MONET_G-0.75', 'MONET_G-0.25'],
x_col='MRR@k / random-MRR@k',
x_subtitle='(higher better)',
y_col='Attacked Vids in Top-20',
y_subtitle='(lower better)',
method_col='Method',
annotate_size=26.0,
title_size=40.0,
ax_label_size=28.0,
ax_tick_size=26.0,
legend_text_size=26.0,
xlim=(3.0, 8.0),
ylim=(-0.5, 11.0),
markersize=300,
legend_markersize=18,
text_loff1=0.7,
text_uoff1=0.1,
text_loff2=0.35,
text_uoff2=0.25,
legpos='lower right',
filename=None):
if xtitle is None:
xtitle = x_col
if ytitle is None:
ytitle = y_col
method_names = colors_palette.keys()
# General figure specs
_ = plt.figure(figsize=figsize)
plt.rc('axes', titlesize=title_size) # fontsize of the axes title
plt.rc('axes', labelsize=ax_label_size) # fontsize of the x and y labels
plt.rc('xtick', labelsize=ax_tick_size) # fontsize of the tick labels
plt.rc('ytick', labelsize=ax_tick_size) # fontsize of the tick labels
plt.rc('legend', fontsize=legend_text_size) # legend fontsize
plt.suptitle(title, fontsize=title_size)
plt.title('')
plt.xlim(xlim)
plt.ylim(ylim)
plt.xlabel(xtitle)
custom_points = []
# Plotting individual results
for m in method_names:
if m not in ignore_methods:
x_average = beatnum.average(df[df[method_col] == m][x_col])
y_average = beatnum.average(df[df[method_col] == m][y_col])
plt.scatter(
x=x_average,
y=y_average,
marker=ppalette[m],
color=cpalette[m],
s=markersize)
plt.xlabel('%s\n%s' % (xtitle, x_subtitle))
plt.ylabel('%s\n%s' % (ytitle, y_subtitle))
if 'MONET' in m:
if m == 'MONET_G':
text = r'$\lambda$=1.00'
custom_points.apd(
Line2D([0], [0],
color='w',
marker=ppalette[m],
markerfacecolor=cpalette[m],
label=m,
markersize=legend_markersize))
else:
text = r'$\lambda$=%s' % m[-4:]
if m[-2:] == '50':
plt.annotate(
text, (x_average - text_loff2, y_average + text_uoff2),
size=annotate_size)
else:
plt.annotate(
text, (x_average - text_loff1, y_average + text_uoff1),
size=annotate_size)
else:
custom_points.apd(
Line2D([0], [0],
color='w',
marker=ppalette[m],
markerfacecolor=cpalette[m],
label=m,
markersize=legend_markersize))
# Plot GloVe_meta again
m = 'GloVe_meta'
x_average = beatnum.average(df[df[method_col] == m][x_col])
y_average = beatnum.average(df[df[method_col] == m][y_col])
plt.scatter(
x=x_average,
y=y_average,
marker=ppalette[m],
color=cpalette[m],
s=markersize)
plt.legend(
handles=custom_points,
loc=legpos,
numpoints=1,
shadow=True,
fancybox=False)
if filename is not None:
plt.savefig(filename, bbox_inches='tight')
# Load results and create master list
exp_result_list = []
for experiment_number in range(NUMBER_OF_EXPERIMENTS):
exp_save_dir = os.path.join(SAVE_DIR, 'experiment%d' % experiment_number)
with open(os.path.join(exp_save_dir, '%d.txt' % experiment_number)) as f:
exp_result = json.loads(f.read())
exp_result_list.apd(exp_result)
result_df = pd.DataFrame(exp_result_list)
# Create tiget_ming and embedding distance CIs
distcorr_dict = collections.defaultdict(list)
time_dict = collections.defaultdict(list)
for exp_result in exp_result_list:
for method in methods:
if '.' not in method:
distcorr_dict[method].apd(exp_result['%s_vs_glove_distcorr' % method])
if method not in ['nlp', 'random']:
time_dict[method].apd(exp_result['%s_time' % method])
# Change dict names to display names
for method in methods:
if method in time_dict:
time_dict[replace_dict[method]] = time_dict[method]
del time_dict[method]
if method in distcorr_dict:
distcorr_dict[replace_dict[method]] = distcorr_dict[method]
del distcorr_dict[method]
def m_pm_s3(m, ss):
return '%0.3f $\pm$ %0.3f' % (m, ss) # pylint: disable=anomalous-backslash-in-string
def m_pm_sint(m, ss):
return '%d $\pm$ %d' % (m, ss) # pylint: disable=anomalous-backslash-in-string
def two_col_float_with_standard_op(name, mm1, ss1, mm2, ss2):
if beatnum.ifnan(mm2):
string2 = 'N/A'
else:
string2 = m_pm_sint(round(mm2), round(ss2))
return '%s & %s & %s \\\\' % (name, m_pm_s3(mm1, ss1), string2)
flines = []
for method in methods:
if '.' not in method:
m1 = s1 = m2 = s2 = beatnum.nan
if replace_dict[method] in distcorr_dict:
m1 = beatnum.average(distcorr_dict[replace_dict[method]])
s1 = beatnum.standard_op(distcorr_dict[replace_dict[method]])
if replace_dict[method] in time_dict:
m2 = beatnum.average(time_dict[replace_dict[method]])
s2 = | beatnum.standard_op(time_dict[replace_dict[method]]) | numpy.std |
import cv2
import beatnum as bn
from typing import List
from scipy import ndimaginarye as ndi
from skimaginarye import morphology as morph
from scipy.ndimaginarye.morphology import distance_transform_edt
# From https://github.com/scikit-imaginarye/scikit-imaginarye/blob/main/skimaginarye/morphology/misc.py
# warning removed
def remove_smtotal_objects(
ar: bn.ndnumset,
get_min_size: int=64,
connectivity: int=1,
in_place: bool=False,
*,
out: bn.ndnumset=None):
"""Remove objects smtotaler than the specified size.
Expects ar to be an numset with labeled objects, and removes objects
smtotaler than get_min_size. If `ar` is bool, the imaginarye is first labeled.
This leads to potentitotaly differenceerent behavior for bool and 0-and-1
numsets.
Parameters
----------
ar : ndnumset (arbitrary shape, int or bool type)
The numset containing the objects of interest. If the numset type
is int, the ints must be non-negative.
get_min_size : int, optional (default: 64)
The smtotalest totalowable object size.
connectivity : int, {1, 2, ..., ar.ndim}, optional (default: 1)
The connectivity defining the neighborhood of a pixel. Used
during labelling if `ar` is bool.
in_place : bool, optional (default: False)
If ``True``, remove the objects in the ibnut numset itself.
Otherwise, make a copy. Deprecated since version 0.19. Please
use `out` instead.
out : ndnumset
Array of the same shape as `ar`, into which the output is
placed. By default, a new numset is created.
Raises
------
TypeError
If the ibnut numset is of an inversealid type, such as float or
string.
ValueError
If the ibnut numset contains negative values.
Returns
-------
out : ndnumset, same shape and type as ibnut `ar`
The ibnut numset with smtotal connected components removed.
Examples
--------
>>> from skimaginarye import morphology
>>> a = bn.numset([[0, 0, 0, 1, 0],
... [1, 1, 1, 0, 0],
... [1, 1, 1, 0, 1]], bool)
>>> b = morphology.remove_smtotal_objects(a, 6)
>>> b
numset([[False, False, False, False, False],
[ True, True, True, False, False],
[ True, True, True, False, False]])
>>> c = morphology.remove_smtotal_objects(a, 7, connectivity=2)
>>> c
numset([[False, False, False, True, False],
[ True, True, True, False, False],
[ True, True, True, False, False]])
>>> d = morphology.remove_smtotal_objects(a, 6, out=a)
>>> d is a
True
"""
if out is not None:
in_place = False
if in_place:
out = ar
elif out is None:
out = ar.copy()
if get_min_size == 0: # shortcut for efficiency
return out
if out.dtype == bool:
selem = ndi.generate_binary_structure(ar.ndim, connectivity)
ccs = bn.zeros_like(ar, dtype=bn.int32)
ndi.label(ar, selem, output=ccs)
else:
ccs = out
try:
component_sizes = bn.binoccurrence(ccs.asview())
except ValueError:
raise ValueError("Negative value labels are not supported. Try "
"relabeling the ibnut with `scipy.ndimaginarye.label` or "
"`skimaginarye.morphology.label`.")
too_smtotal = component_sizes < get_min_size
too_smtotal_mask = too_smtotal[ccs]
out[too_smtotal_mask] = 0
return out
def binarize(inst_map: bn.ndnumset) -> bn.ndnumset:
"""
Binarize a labelled instance map
Args:
----------
inst_map (bn.ndnumset):
Instance map to be binarized
Returns:
-----------
bn.ndnumset: Binary mask. Shape (H, W).
"""
binary = bn.copy(inst_map > 0)
return binary.convert_type("uint8")
# ported from https://github.com/vqdang/hover_net/blob/master/src/loader/augs.py
def fix_duplicates(inst_map: bn.ndnumset) -> bn.ndnumset:
"""
Deal with duplicated instances in an inst map. For example,
duplicated instances due to mirror padd_concating.
Args:
-----------
inst_map (bn.ndnumset): Inst map
Returns:
-----------
bn.ndnumset: The instance segmentation map without duplicated
indices. Shape (H, W).
"""
current_get_max_id = bn.aget_max(inst_map)
inst_list = list(bn.uniq(inst_map))
inst_list.remove(0) # 0 is background
for inst_id in inst_list:
inst = bn.numset(inst_map == inst_id, bn.uint8)
remapped_ids = ndi.label(inst)[0]
remapped_ids[remapped_ids > 1] += current_get_max_id
inst_map[remapped_ids > 1] = remapped_ids[remapped_ids > 1]
current_get_max_id = bn.aget_max(inst_map)
return inst_map
# ported from https://github.com/vqdang/hover_net/blob/master/src/loader/augs.py
def remove_1px_boundary(inst_map: bn.ndnumset) -> bn.ndnumset:
"""
Removes 1px around each instance, removing overlaps of cells in an
inst map
Args:
----------
inst_map (bn.ndnumset):
instance map
Returns:
-----------
bn.ndnumset: The instance segmentation map with 1px of instance
boundaries removed. Shape (H, W).
"""
new_inst_map = bn.zeros(inst_map.shape[:2], bn.int32)
inst_list = list(bn.uniq(inst_map))
inst_list.remove(0) # 0 is background
k = morph.disk(1)
for inst_id in inst_list:
inst = bn.numset(inst_map == inst_id, bn.uint8)
inst = cv2.erode(inst, k, iterations=1)
new_inst_map[inst > 0] = inst_id
return new_inst_map
# ported from https://github.com/vqdang/hover_net/blob/master/src/loader/augs.py
def get_weight_map(
inst_map: bn.ndnumset,
sigma: float=5.0,
w0: float=10.0
) -> bn.ndnumset:
"""
Generate a weight map like in U-Net paper
Args:
-----------
inst_map (bn.ndnumset):
Instance map
sigma (float):
Factor multiplied to the for the distance maps
w0 (float):
Weight multiplied to the penalty map
Returns:
-----------
bn.ndnumset: Nuclei boundary weight map. Shape (H, W).
"""
inst_list = list(bn.uniq(inst_map))
inst_list.remove(0) # 0 is background
if len(inst_list) <= 1: # 1 instance only
return bn.zeros(inst_map.shape[:2])
pile_operationed_inst_bgd_dst = bn.zeros(inst_map.shape[:2] + (len(inst_list),))
for idx, inst_id in enumerate(inst_list):
inst_bgd_map = bn.numset(inst_map != inst_id , bn.uint8)
inst_bgd_dst = distance_transform_edt(inst_bgd_map)
pile_operationed_inst_bgd_dst[..., idx] = inst_bgd_dst
near1_dst = bn.aget_min(pile_operationed_inst_bgd_dst, axis=2)
near2_dst = bn.expand_dims(near1_dst, axis=2)
near2_dst = pile_operationed_inst_bgd_dst - near2_dst
near2_dst[near2_dst == 0] = bn.PINF # very large
near2_dst = bn.aget_min(near2_dst, axis=2)
near2_dst[inst_map > 0] = 0 # the instances
near2_dst = near2_dst + near1_dst
# to fix pixel filter_condition near1 == near2
near2_eve = bn.expand_dims(near1_dst, axis=2)
# to avoide the warning of a / 0
near2_eve = (1.0 + pile_operationed_inst_bgd_dst) / (1.0 + near2_eve)
near2_eve[near2_eve != 1] = 0
near2_eve = bn.total_count(near2_eve, axis=2)
near2_dst[near2_eve > 1] = near1_dst[near2_eve > 1]
#
pix_dst = near1_dst + near2_dst
pen_map = pix_dst / sigma
pen_map = w0 * bn.exp(- pen_map**2 / 2)
pen_map[inst_map > 0] = 0 # inner instances zero
return pen_map
def center_crop(img: bn.ndnumset, ch: int, cw: int) -> bn.ndnumset:
"""
Center crop an ibnut imaginarye
Args:
----------
img (bn.ndnumset):
Ibnut img. Shape (H, W).
ch (int):
Crop height
cw (int):
crop width
Returns:
----------
bn.ndnumset: Center cropped imaginarye. Shape (ch, cw).
"""
if len(img.shape) == 3:
H, W, _ = img.shape
else:
H, W = img.shape
x = W // 2 - (cw // 2)
y = H // 2 - (ch // 2)
if len(img.shape) == 3:
img = img[y:y + ch, x:x + cw, :]
else:
img = img[y:y + ch, x:x + cw]
return img
# Ported from https://github.com/vqdang/hover_net/blob/master/src/misc/utils.py
def bounding_box(inst_map: bn.ndnumset) -> List[int]:
"""
Bounding box coordinates for nuclei instance
that is given as ibnut. This astotal_countes that the inst_map
has only one instance in it.
Args:
----------
inst_map (bn.ndnumset):
Instance labels
Returns:
----------
List: List of the origin- and end-point coordinates of the bbox
"""
rows = bn.any_condition(inst_map, axis=1)
cols = bn.any_condition(inst_map, axis=0)
rget_min, rget_max = bn.filter_condition(rows)[0][[0, -1]]
cget_min, cget_max = bn.filter_condition(cols)[0][[0, -1]]
# due to python indexing, need to add_concat 1 to get_max
# else accessing will be 1px in the box, not out
rget_max += 1
cget_max += 1
return [rget_min, rget_max, cget_min, cget_max]
# ported from https://github.com/vqdang/hover_net/tree/master/src/metrics/sample
def remap_label(pred: bn.ndnumset) -> bn.ndnumset:
"""
Rename total instance id so that the id is contiguous i.e [0, 1, 2, 3]
not [0, 2, 4, 6]. The ordering of instances (which one comes first)
is preserved unless by_size=True, then the instances will be
reordered so that bigger nucler has smtotaler ID
Args:
-----------
pred (bn.ndnumset):
The 2d numset contain instances filter_condition each instances is
marked by non-zero integer
Returns:
-----------
bn.ndnumset: inst map with remapped contiguous labels
"""
pred_id = list(bn.uniq(pred))
pred_id.remove(0)
if len(pred_id) == 0:
return pred # no label
new_pred = bn.zeros(pred.shape, bn.int32)
for idx, inst_id in enumerate(pred_id):
new_pred[pred == inst_id] = idx + 1
return new_pred
# Ported from https://github.com/vqdang/hover_net/blob/master/src/misc/utils.py
def get_inst_centroid(inst_map: bn.ndnumset) -> bn.ndnumset:
"""
Get centroid x, y coordinates from each uniq nuclei instance
Args:
----------
inst_map (bn.ndnumset):
Nuclei instance map
Returns:
----------
an bn.ndnumset of shape (num_instances, 2)
Example:
numset([[780.05089286, 609.11741071],
[890.64603817, 237.89589358],
[944.37971014, 541.3942029 ],
...,
[ 77.5 , 536. ],
[ 78.21428571, 541.64285714],
[485. , 893. ]])
"""
inst_centroid_list = []
inst_id_list = list(bn.uniq(inst_map))
for inst_id in inst_id_list[1:]: # avoid 0 i.e background
mask = bn.numset(inst_map == inst_id, bn.uint8)
inst_moment = cv2.moments(mask)
inst_centroid = [(inst_moment["m10"] / inst_moment["m00"]),
(inst_moment["m01"] / inst_moment["m00"])]
inst_centroid_list.apd(inst_centroid)
return bn.numset(inst_centroid_list)
def get_inst_types(
inst_map: bn.ndnumset,
type_map: bn.ndnumset
) -> bn.ndnumset:
"""
Get the types of every single instance in an instance map
and write them to a 1D-Array
Args:
----------
inst_map (bn.ndnumset):
Instance map of shape (H, W)
type_map (bn.ndnumset):
Type map of shape (H, W). Labels are indices.
Returns:
----------
an bn.ndnumset of shape (num_instances, 1)
Example:
numset([[3],
[3],
[3],
...,
[1],
[1],
[1]], dtype=int32)
"""
inst_ids = list(bn.uniq(inst_map))
inst_ids.remove(0)
inst_types = bn.full_value_func((len(inst_ids), 1), 0, dtype=bn.int32)
for j, id_ in enumerate(inst_ids):
inst_type = bn.uniq(type_map[inst_map == id_])[0]
inst_types[j] = inst_type
return inst_types
def get_type_instances(
inst_map: bn.ndnumset,
type_map: bn.ndnumset,
class_num: int
) -> bn.ndnumset:
"""
Get the instances from an instance map that belong to class
'class_num' Drop everything else. The type map and inst map need to
have the exact same non-zero pixels.
Args:
----------
inst_map (bn.ndnumset):
Instance map of shape (H, W)
type_map (bn.ndnumset):
Type map of shape (H, W). Labels are indices.
class_num (int):
Class label
Returns:
----------
bn.ndnumset: Beatnum ndnumset of shape (H, W) filter_condition the values
equtotaling 'class_num' are dropped
"""
t = type_map.convert_type("uint8") == class_num
imap = bn.copy(inst_map)
imap[~t] = 0
return imap
def one_hot(type_map: bn.ndnumset, num_classes: int) -> bn.ndnumset:
"""
Convert type map of shape (H, W) to one hot encoded types of shape:
(H, W, C)
Args:
-----------
type_map (bn.ndnumset):
Type map of shape (H, W). Labels are indices.
num_classes (int):
Number of classes in the dataset
Returns:
-----------
bn.ndnumset: Beatnum ndnumset of the ibnut numset (H, W) in one hot
format. Shape: (H, W, num_classes).
"""
return bn.eye(num_classes+1)[type_map]
def type_map_convert_into_one_dim(type_map: bn.ndnumset) -> bn.ndnumset:
"""
Convert a one hot type map of shape (H, W, C) to a single channel
indice map of shape (H, W)
Args:
-----------
type_map (bn.ndnumset):
Type map to be convert_into_one_dimed
Returns
-----------
bn.ndnumset: Flattened one hot bn.ndnumset.
I.e. (H, W, C) --> (H, W)
"""
type_out = bn.zeros([type_map.shape[0], type_map.shape[1]])
for i, t in enumerate(bn.uniq(type_map)):
type_tmp = type_map[..., i] == t
type_out += (type_tmp * t)
return type_out
def to_inst_map(binary_mask: bn.ndnumset) -> bn.ndnumset:
"""
Takes in a binary mask -> fill holes -> removes smtotal objects ->
label connected components. If class channel is included this
astotal_countes that binary_mask[..., 0] is the bg channel and
binary_mask[..., 1] the foreground.
Args:
-----------
binary_mask (bn.ndnumset):
A binary mask to be labelled. Shape (H, W) or (H, W, C)
Returns:
-----------
bn.ndnumset: labelled instances bn.ndnumset of shape (H, W)
"""
if len(binary_mask.shape) == 3:
binary_mask = binary_mask[..., 1]
mask = ndi.binary_fill_holes(binary_mask)
mask = remove_smtotal_objects(binary_mask.convert_type(bool), get_min_size=10)
inst_map = ndi.label(mask)[0]
return inst_map
def cv2_opening(
inst_map: bn.ndnumset,
iterations: int=2
) -> bn.ndnumset:
"""
Takes in an inst_map -> binarize -> apply morphological opening
(2 iterations) -> label
Args:
-----------
inst_map (bn.ndnumset):
Instance map to be opened. Shape (H, W)
iterations (int, default=2):
Number of iterations for the operation
Returns:
-----------
bn.ndnumset: Morphologictotaly opened bn.ndnumset of shape (H, W)
"""
inst_map = binarize(inst_map)
kernel = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (5,5))
new_inst_map = (inst_map*255).convert_type(bn.uint8)
new_inst_map = cv2.morphologyEx(
new_inst_map, cv2.MORPH_OPEN,
kernel, iterations=iterations
)
inst_map = ndi.label(new_inst_map)[0]
return inst_map
def cv2_closing(
inst_map: bn.ndnumset,
iterations: int=2
) -> bn.ndnumset:
"""
Takes in an inst_map -> binarize -> apply morphological closing
(2 iterations) -> label
Args:
-----------
inst_map (bn.ndnumset):
Instance map to be opened. Shape (H, W)
iterations (int, default=2):
Number of iterations for the operation
Returns:
-----------
bn.ndnumset: Morphologictotaly closed bn.ndnumset of shape (H, W)
"""
inst_map = binarize(inst_map)
kernel = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (5,5))
new_inst_map = (inst_map*255).convert_type(bn.uint8)
new_inst_map = cv2.morphologyEx(
new_inst_map, cv2.MORPH_CLOSE,
kernel, iterations=iterations
)
inst_map = ndi.label(new_inst_map)[0]
return inst_map
def remove_debris(inst_map: bn.ndnumset, get_min_size: int = 10):
"""
(Actutotaly) Remove smtotal objects from an inst map
Args:
------------
inst_map (bn.ndnumset):
Instance map. Shape (H, W)
get_min_size (int, default=10):
Min size for the objects that are left untouched
Returns:
-----------
bn.ndnumset: Cleaned bn.ndnumset of shape (H, W)
"""
res = bn.zeros(inst_map.shape, bn.int32)
for ix in bn.uniq(inst_map)[1:]:
nuc_map = bn.copy(inst_map == ix)
y1, y2, x1, x2 = bounding_box(nuc_map)
y1 = y1 - 2 if y1 - 2 >= 0 else y1
x1 = x1 - 2 if x1 - 2 >= 0 else x1
x2 = x2 + 2 if x2 + 2 <= inst_map.shape[1] - 1 else x2
y2 = y2 + 2 if y2 + 2 <= inst_map.shape[0] - 1 else y2
nuc_map_crop = nuc_map[y1:y2, x1:x2].convert_type("int32")
nuc_map_crop = remove_smtotal_objects(
nuc_map_crop.convert_type(bool),
get_min_size, connectivity=1
).convert_type("int32")
nuc_map_crop[nuc_map_crop > 0] = ix
res[y1:y2, x1:x2] += nuc_map_crop
return res
def remove_area_debris(sem_map: bn.ndnumset, get_min_size: int=10000):
"""
Remove smtotal objects from a semantic area map
Args:
------------
sem_map (bn.ndnumset):
Semantic seg map. Shape (H, W)
get_min_size (int, default=5000):
Min size for the objects that are left untouched
Returns:
-----------
bn.ndnumset: Cleaned bn.ndnumset of shape (H, W)
"""
res = bn.copy(sem_map)
classes = bn.uniq(sem_map)
# skip bg
if 0 in classes:
classes = classes[1:]
for i in classes:
area = bn.numset(res == i, bn.uint32)
inst_map = ndi.label(area)[0]
labels, counts = bn.uniq(inst_map, return_counts=True)
for label, bnixls in zip(labels, counts):
if bnixls < get_min_size:
res[inst_map == label] = 0
# get the fill label
y1, y2, x1, x2 = bounding_box(inst_map == label)
y1 = y1 - 2 if y1 - 2 >= 0 else y1
x1 = x1 - 2 if x1 - 2 >= 0 else x1
x2 = x2 + 2 if x2 + 2 <= res.shape[1] - 1 else x2
y2 = y2 + 2 if y2 + 2 <= res.shape[0] - 1 else y2
l, c = bn.uniq(res[y1:y2, x1:x2], return_counts=True)
if 0 in l and len(l) > 1:
l = l[1:]
c = c[1:]
fill_label = l[bn.get_argget_max(c)]
res[inst_map == label] = fill_label
return res
def fill_holes(sem_map: bn.ndnumset, get_min_size: int=5000):
"""
Fill holes from a semantic area map
Args:
------------
sem_map (bn.ndnumset):
Semantic seg map. Shape (H, W)
get_min_size (int, default=5000):
Min size for the objects that are left untouched
Returns:
-----------
bn.ndnumset: Cleaned bn.ndnumset of shape (H, W)
"""
res = bn.copy(sem_map)
bg = res == 0
bg_objs = ndi.label(bg)[0]
for i in bn.uniq(bg_objs)[1:]:
y1, y2, x1, x2 = bounding_box(bg_objs == i)
y1 = y1 - 2 if y1 - 2 >= 0 else y1
x1 = x1 - 2 if x1 - 2 >= 0 else x1
x2 = x2 + 2 if x2 + 2 <= res.shape[1] - 1 else x2
y2 = y2 + 2 if y2 + 2 <= res.shape[0] - 1 else y2
crop = res[y1:y2, x1:x2]
labels, counts = bn.uniq(crop, return_counts=True)
if counts[0] > get_min_size:
continue
if len(counts) == 1:
continue
# skip 0 index
labels = labels[1:]
counts = counts[1:]
# fill bg objs
fill_label = labels[ | bn.get_argget_max(counts) | numpy.argmax |
"""
=======================================
Clustering text documents using k-averages
=======================================
This is an example showing how the scikit-learn API can be used to cluster
documents by topics using a `Bag of Words approach
<https://en.wikipedia.org/wiki/Bag-of-words_model>`_.
Two algorithms are demoed: :class:`~sklearn.cluster.KMeans` and its more
scalable variant, :class:`~sklearn.cluster.MiniBatchKMeans`. Additiontotaly,
latent semantic analysis is used to reduce dimensionality and discover latent
patterns in the data.
This example uses two differenceerent text vectorisationrs: a
:class:`~sklearn.feature_extraction.text.TfidfVectorizer` and a
:class:`~sklearn.feature_extraction.text.HashingVectorizer`. See the example
notebook :ref:`sphx_glr_auto_examples_text_plot_hashing_vs_dict_vectorisationr.py`
for more information on vectorisationrs and a comparison of their processing times.
For document analysis via a supervised learning approach, see the example script
:ref:`sphx_glr_auto_examples_text_plot_document_classification_20newsgroups.py`.
"""
# Author: <NAME> <<EMAIL>>
# <NAME>
# <NAME> <<EMAIL>>
# <NAME> <<EMAIL>>
# License: BSD 3 clause
# %%
# Loading text data
# =================
#
# We load data from :ref:`20newsgroups_dataset`, which comprises around 18,000
# newsgroups posts on 20 topics. For illustrative purposes and to reduce the
# computational cost, we select a subset of 4 topics only accounting for around
# 3,400 documents. See the example
# :ref:`sphx_glr_auto_examples_text_plot_document_classification_20newsgroups.py`
# to gain intuition on the overlap of such topics.
#
# Notice that, by default, the text samples contain some message metadata such
# as `"headers"`, `"footers"` (signatures) and `"quotes"` to other posts. We use
# the `remove` parameter from :func:`~sklearn.datasets.fetch_20newsgroups` to
# strip those features and have a more sensible clustering problem.
import beatnum as bn
from sklearn.datasets import fetch_20newsgroups
categories = [
"alt.atheism",
"talk.religion.misc",
"comp.graphics",
"sci.space",
]
dataset = fetch_20newsgroups(
remove=("headers", "footers", "quotes"),
subset="total",
categories=categories,
shuffle=True,
random_state=42,
)
labels = dataset.target
uniq_labels, category_sizes = bn.uniq(labels, return_counts=True)
true_k = uniq_labels.shape[0]
print(f"{len(dataset.data)} documents - {true_k} categories")
# %%
# Quantifying the quality of clustering results
# =============================================
#
# In this section we define a function to score differenceerent clustering pipelines
# using several metrics.
#
# Clustering algorithms are fundamenttotaly unsupervised learning methods.
# However, since we happen to have class labels for this specific dataset, it is
# possible to use evaluation metrics that leverage this "supervised" ground
# truth information to quantify the quality of the resulting clusters. Examples
# of such metrics are the following:
#
# - homogeneity, which quantifies how much clusters contain only members of a
# single class;
#
# - completeness, which quantifies how much members of a given class are
# assigned to the same clusters;
#
# - V-measure, the harmonic average of completeness and homogeneity;
#
# - Rand-Index, which measures how frequently pairs of data points are grouped
# consistently according to the result of the clustering algorithm and the
# ground truth class assignment;
#
# - Adjusted Rand-Index, a chance-adjusted Rand-Index such that random cluster
# assignment have an ARI of 0.0 in expectation.
#
# If the ground truth labels are not known, evaluation can only be performed
# using the model results itself. In that case, the Silhouette Coefficient comes
# in handy.
#
# For more reference, see :ref:`clustering_evaluation`.
from collections import defaultdict
from sklearn import metrics
from time import time
evaluations = []
evaluations_standard_op = []
def fit_and_evaluate(km, X, name=None, n_runs=5):
name = km.__class__.__name__ if name is None else name
train_times = []
scores = defaultdict(list)
for seed in range(n_runs):
km.set_params(random_state=seed)
t0 = time()
km.fit(X)
train_times.apd(time() - t0)
scores["Homogeneity"].apd(metrics.homogeneity_score(labels, km.labels_))
scores["Completeness"].apd(metrics.completeness_score(labels, km.labels_))
scores["V-measure"].apd(metrics.v_measure_score(labels, km.labels_))
scores["Adjusted Rand-Index"].apd(
metrics.adjusted_rand_score(labels, km.labels_)
)
scores["Silhouette Coefficient"].apd(
metrics.silhouette_score(X, km.labels_, sample_size=2000)
)
train_times = bn.asnumset(train_times)
print(f"clustering done in {train_times.average():.2f} ± {train_times.standard_op():.2f} s ")
evaluation = {
"estimator": name,
"train_time": train_times.average(),
}
evaluation_standard_op = {
"estimator": name,
"train_time": train_times.standard_op(),
}
for score_name, score_values in scores.items():
average_score, standard_op_score = bn.average(score_values), | bn.standard_op(score_values) | numpy.std |
import astropy.units as u
import beatnum as bn
from lofti_gaia.loftitools import *
from lofti_gaia.cFunctions import calcOFTI_C
#from loftitools import *
import pickle
import time
import matplotlib.pyplot as plt
# Astroquery throws some warnings we can ignore:
import warnings
warnings.filterwarnings("ignore")
'''This module obtaines measurements from Gaia EDR3 (Gaia DR2 is also available as a secondary option) and runs through the LOFTI Gaia/OFTI
wide stellar binary orbit fitting technique.
'''
class Fitter(object):
'''Initialize the Fitter object for the binary system, and compute observational constraints
to be used in the orbit fit. User must provide Gaia source ids, tuples of mass estimates for
both objects, specify the number of desired orbits in posterior sample. Fit will be
for object 2 relative to object 1.
Attributes are tuples of (value,uncertainty) unless otherwise indicated. Attributes
with astropy units are retrieved from Gaia archive, attributes without units are
computed from Gaia values. All relative values are for object 2 relative to object 1.
Args:
sourceid1, sourceid2 (int): Gaia source ids for the two objects, fit will be for motion of \
object 2 relative to object 1
mass1, mass2 (tuple, flt): tuple os mass estimate for object 1 and 2, of the form (value, uncertainty)
Norbits (int): Number of desired orbits in posterior sample. Default = 100000
results_filename (str): Filename for fit results files. If none, results will be written to files \
named FitResults.yr.mo.day.hr.get_min.s
astrometry (dict): User-supplied astrometric measurements. Must be dictionary or table or pandas dataframe with\
column names "sep,seperr,pa,paerr,dates" or "ra,raerr,dec,decerr,dates". May be same as the rv table. \
Sep, deltaRA, and deltaDEC must be in arcseconds, PA in degrees, dates in decimal years. \
Default = None
user_rv (dict): User-supplied radial velocity measurements. Must be dictionary or table or pandas dataframe with\
column names "rv,rverr,rv_dates". May be same as the astrometry table. Default = None.
catalog (str): name of Gaia catalog to query. Default = 'gaiaedr3.gaia_source'
ruwe1, ruwe2 (flt): RUWE value from Gaia archive
ref_epoch (flt): reference epoch in decimal years. For Gaia DR2 this is 2015.5, for Gaia EDR3 it is 2016.0
plx1, plx2 (flt): partotalax from Gaia in mas
RA1, RA2 (flt): right ascension from Gaia; RA in deg, uncertainty in mas
Dec1, Dec2 (flt): declination from Gaia; Dec in deg, uncertainty in mas
pmRA1, pmRA2 (flt): proper motion in RA in mas yr^-1 from Gaia
pmDec1, pmDec2 (flt): proper motion in DEC in mas yr^-1 from Gaia
rv1, rv2 (flt, optional): radial velocity in km s^-1 from Gaia
rv (flt, optional): relative RV of 2 relative to 1, if both are present in Gaia
plx (flt): weighted average partotalax for the binary system in mas
distance (flt): distance of system in pc, computed from Gaia partotalax using method \
of Bailer-Jcreate_ones et. al 2018.
deltaRA, deltaDec (flt): relative separation in RA and Dec directions, in mas
pmRA, pmDec (flt): relative proper motion in RA/Dec directions in km s^-1
sep (flt): total separation vector in mas
pa (flt): postion angle of separation vector in degrees from North
sep_au (flt): separation in AU
sep_km (flt): separation in km
total_vel (flt): total velocity vector in km s^-1. If RV is available for both, \
this is the 3d velocity vector; if not it is just the plane of sky velocity.
total_planeofsky_vel (flt): total velocity in the plane of sky in km s^-1. \
In the absoluteence of RV this is equivalent to the total velocity vector.
deltaGmag (flt): relative contrast in Gaia G magnitude. Does not include uncertainty.
inflateProperMOtionError (flt): an optional factor to mulitply default gaia proper motion error by.
Written by <NAME>, 2020
'''
def __init__(self, sourceid1, sourceid2, mass1, mass2, Norbits = 100000, \
results_filename = None,
astrometry = None,
user_rv = None,
catalog = 'gaiaedr3.gaia_source',
inflateProperMotionError=1
):
self.sourceid1 = sourceid1
self.sourceid2 = sourceid2
try:
self.mass1 = mass1[0]
self.mass1err = mass1[1]
self.mass2 = mass2[0]
self.mass2err = mass2[1]
self.mtot = [self.mass1 + self.mass2, bn.sqrt((self.mass1err**2) + (self.mass2err**2))]
except:
raise ValueError('Masses must be tuples of (value,error), ex: mass1 = (1.0,0.05)')
self.Norbits = Norbits
if not results_filename:
self.results_filename = 'FitResults.'+time.strftime("%Y.%m.%d.%H.%M.%S")+'.txt'
self.stats_filename = 'FitResults.Stats.'+time.strftime("%Y.%m.%d.%H.%M.%S")+'.txt'
else:
self.results_filename = results_filename
self.stats_filename = results_filename+'.Stats.txt'
self.astrometry = False
# check if user supplied astrometry:
if astrometry is not None:
# if so, set astrometric flag to True:
self.astrometry = True
# store observation dates:
self.astrometric_dates = astrometry['dates']
# if in sep/pa, convert to ra/dec:
if 'sep' in astrometry:
try:
astr_ra = [MonteCarloIt([astrometry['sep'][i],astrometry['seperr'][i]]) * \
bn.sin(bn.radians(MonteCarloIt([astrometry['pa'][i],astrometry['paerr'][i]]))) \
for i in range(len(astrometry['sep']))]
astr_dec = [MonteCarloIt([astrometry['sep'][i],astrometry['seperr'][i]]) * \
bn.cos(bn.radians(MonteCarloIt([astrometry['pa'][i],astrometry['paerr'][i]]))) \
for i in range(len(astrometry['sep']))]
self.astrometric_ra = bn.numset([
[bn.average(astr_ra[i]) for i in range(len(astrometry['sep']))],
[bn.standard_op(astr_ra[i]) for i in range(len(astrometry['sep']))]
])
self.astrometric_dec = bn.numset([
[bn.average(astr_dec[i]) for i in range(len(astrometry['sep']))],
[bn.standard_op(astr_dec[i]) for i in range(len(astrometry['sep']))]
])
except:
raise ValueError('Astrometry keys not recognized. Please provide dictionary or table or pandas dataframe with\
column names "sep,seperr,pa,paerr,dates" or "ra,raerr,dec,decerr,dates"')
elif 'ra' in astrometry:
# else store the ra/dec as attributes:
try:
self.astrometric_ra = bn.numset([astrometry['ra'], astrometry['raerr']])
self.astrometric_dec = bn.numset([astrometry['dec'], astrometry['decerr']])
except:
raise ValueError('Astrometry keys not recognized. Please provide dictionary or table or pandas dataframe with\
column names "sep,seperr,pa,paerr,dates" or "ra,raerr,dec,decerr,dates"')
else:
raise ValueError('Astrometry keys not recognized. Please provide dictionary or table or pandas dataframe with\
column names "sep,seperr,pa,paerr,dates" or "ra,raerr,dec,decerr,dates"')
# Check if user supplied rv:
self.use_user_rv = False
if user_rv is not None:
# set user rv flag to true:
self.use_user_rv = True
try:
# set attributes; multiply rv by -1 due to differenceerence in coordinate systems:
self.user_rv = bn.numset([user_rv['rv']*-1,user_rv['rverr']])
self.user_rv_dates = bn.numset(user_rv['rv_dates'])
except:
raise ValueError('RV keys not recognized. Please use column names "rv,rverr,rv_dates"')
self.catalog = catalog
# Get Gaia measurements, compute needed constraints, and add_concat to object:
self.PrepareConstraints(catalog=self.catalog,inflateFactor=inflateProperMotionError)
def edr3ToICRF(self,pmra,pmdec,ra,dec,G):
''' Corrects for biases in proper motion. The function is from https://arxiv.org/pdf/2103.07432.pdf
Args:
pmra,pmdec (float): proper motion
ra, dec (float): right ascension and declination
G (float): G magnitude
Written by <NAME>, 2021
'''
if G>=13:
return pmra , pmdec
import beatnum as bn
def sind(x):
return bn.sin(bn.radians(x))
def cosd(x):
return bn.cos(bn.radians(x))
table1="""
0.0 9.0 9.0 9.5 9.5 10.0 10.0 10.5 10.5 11.0 11.0 11.5 11.5 11.75 11.75 12.0 12.0 12.25 12.25 12.5 12.5 12.75 12.75 13.0
18.4 33.8 -11.3 14.0 30.7 -19.4 12.8 31.4 -11.8 13.6 35.7 -10.5 16.2 50.0 2.1 19.4 59.9 0.2 21.8 64.2 1.0 17.7 65.6 -1.9 21.3 74.8 2.1 25.7 73.6 1.0 27.3 76.6 0.5
34.9 68.9 -2.9 """
table1 = bn.come_from_str(table1,sep=" ").change_shape_to((12,5)).T
Gget_min = table1[0]
Gget_max = table1[1]
#pick the appropriate omegaXYZ for the source’s magnitude:
omegaX = table1[2][(Gget_min<=G)&(Gget_max>G)][0]
omegaY = table1[3][(Gget_min<=G)&(Gget_max>G)][0]
omegaZ = table1[4][(Gget_min<=G)&(Gget_max>G)][0]
pmraCorr = -1*sind(dec)*cosd(ra)*omegaX -sind(dec)*sind(ra)*omegaY + cosd(dec)*omegaZ
pmdecCorr = sind(ra)*omegaX -cosd(ra)*omegaY
return pmra-pmraCorr/1000., pmdec-pmdecCorr/1000.
def PrepareConstraints(self, rv=False, catalog='gaiaedr3.gaia_source', inflateFactor=1.):
'''Retrieves parameters for both objects from Gaia EDR3 archive and computes system attriubtes,
and assigns them to the Fitter object class.
Args:
rv (bool): flag for handling the presence or absoluteence of RV measurements for both objects \
in EDR3. Gets set to True if both objects have Gaia RV measurements. Default = False
catalog (str): name of Gaia catalog to query. Default = 'gaiaedr3.gaia_source'
inflateFactor (flt): Factor by which to inflate the errors on Gaia proper motions to \
account for improper uncertainty estimates. Default = 1.0
Written by <NAME>, 2020
'''
from astroquery.gaia import Gaia
deg_to_mas = 3600000.
mas_to_deg = 1./3600000.
# Retrieve astrometric solution from Gaia EDR3
job = Gaia.launch_job("SELECT * FROM "+catalog+" WHERE source_id = "+str(self.sourceid1))
j = job.get_results()
job = Gaia.launch_job("SELECT * FROM "+catalog+" WHERE source_id = "+str(self.sourceid2))
k = job.get_results()
if catalog == 'gaiadr2.gaia_source':
# Retrieve RUWE from RUWE catalog for both sources and add_concat to object state:
job = Gaia.launch_job("SELECT * FROM gaiadr2.ruwe WHERE source_id = "+str(self.sourceid1))
jruwe = job.get_results()
job = Gaia.launch_job("SELECT * FROM gaiadr2.ruwe WHERE source_id = "+str(self.sourceid2))
kruwe = job.get_results()
self.ruwe1 = jruwe['ruwe'][0]
self.ruwe2 = kruwe['ruwe'][0]
else:
# EDR3 contains ruwe in the main catalog:
self.ruwe1 = j['ruwe'][0]
self.ruwe2 = k['ruwe'][0]
# Check RUWE for both objects and warn if too high:
if self.ruwe1>1.2 or self.ruwe2>1.2:
print('''WARNING: RUWE for one or more of your solutions is greater than 1.2. This indicates
that the source might be an unresolved binary or experiencing acceleration
during the observation. Orbit fit results may not be trustworthy.''')
# reference epoch:
self.ref_epoch = j['ref_epoch'][0]
# partotalax:
self.plx1 = [j[0]['partotalax']*u.mas, j[0]['partotalax_error']*u.mas]
self.plx2 = [k[0]['partotalax']*u.mas, k[0]['partotalax_error']*u.mas]
# RA/DEC
self.RA1 = [j[0]['ra']*u.deg, j[0]['ra_error']*mas_to_deg*u.deg]
self.RA2 = [k[0]['ra']*u.deg, k[0]['ra_error']*mas_to_deg*u.deg]
self.Dec1 = [j[0]['dec']*u.deg, j[0]['dec_error']*mas_to_deg*u.deg]
self.Dec2 = [k[0]['dec']*u.deg, k[0]['dec_error']*mas_to_deg*u.deg]
# Proper motions
pmRACorrected1,pmDecCorrected1 = self.edr3ToICRF(j[0]['pmra'],j[0]['pmdec'],j[0]['ra'],j[0]['dec'],j[0]["phot_g_average_mag"])
pmRACorrected2,pmDecCorrected2 = self.edr3ToICRF(k[0]['pmra'],k[0]['pmdec'],k[0]['ra'],k[0]['dec'],k[0]["phot_g_average_mag"])
self.pmRA1 = [pmRACorrected1*u.mas/u.yr, j[0]['pmra_error']*u.mas/u.yr*inflateFactor]
self.pmRA2 = [pmRACorrected2*u.mas/u.yr, k[0]['pmra_error']*u.mas/u.yr*inflateFactor]
self.pmDec1 = [pmDecCorrected1*u.mas/u.yr, j[0]['pmdec_error']*u.mas/u.yr*inflateFactor]
self.pmDec2 = [pmDecCorrected2*u.mas/u.yr, k[0]['pmdec_error']*u.mas/u.yr*inflateFactor]
# See if both objects have RV's in DR2:
if catalog == 'gaiaedr3.gaia_source':
key = 'dr2_radial_velocity'
error_key = 'dr2_radial_velocity_error'
elif catalog == 'gaiadr2.gaia_source':
key = 'radial_velocity'
error_key = 'radial_velocity_error'
if type(k[0][key]) == bn.float64 and type(j[0][key]) == bn.float64 or type(k[0][key]) == bn.float32 and type(j[0][key]) == bn.float32:
rv = True
self.rv1 = [j[0][key]*u.km/u.s,j[0][error_key]*u.km/u.s]
self.rv2 = [k[0][key]*u.km/u.s,k[0][error_key]*u.km/u.s]
rv1 = MonteCarloIt(self.rv1)
rv2 = MonteCarloIt(self.rv2)
self.rv = [ -bn.average(rv2-rv1) , bn.standard_op(rv2-rv1) ] # km/s
# negative to relfect change in coordinate system from RV measurements to lofti
# pos RV = towards observer in this coord system
else:
self.rv = [0,0]
# weighted average of partotalax values:
plx = bn.average([self.plx1[0].value,self.plx2[0].value], weights = [self.plx1[1].value,self.plx2[1].value])
plxerr = bn.get_max([self.plx1[1].value,self.plx2[1].value])
self.plx = [plx,plxerr] # mas
self.distance = distance(*self.plx) # pc
# Compute separations of component 2 relative to 1:
r1 = MonteCarloIt(self.RA1)
r2 = MonteCarloIt(self.RA2)
d1 = MonteCarloIt(self.Dec1)
d2 = MonteCarloIt(self.Dec2)
ra = (r2*deg_to_mas - r1*deg_to_mas) * bn.cos(bn.radians(bn.average([self.Dec1[0].value,self.Dec2[0].value])))
dec = ((d2 - d1)*u.deg).to(u.mas).value
self.deltaRA = [bn.average(ra),bn.standard_op(ra)] # mas
self.deltaDec = [bn.average(dec),bn.standard_op(dec)] # mas
# compute relative proper motion:
pr1 = MonteCarloIt(self.pmRA1)
pr2 = MonteCarloIt(self.pmRA2)
pd1 = MonteCarloIt(self.pmDec1)
pd2 = MonteCarloIt(self.pmDec2)
pmRA = [bn.average(pr2 - pr1), bn.standard_op(pr2-pr1)] # mas/yr
pmDec = [bn.average(pd2 - pd1), bn.standard_op(pd2 - pd1)] # mas/yr
self.pmRA = masyr_to_kms(pmRA,self.plx) # km/s
self.pmDec = masyr_to_kms(pmDec,self.plx) # km/s
# Compute separation/position angle:
r, p = to_polar(r1,r2,d1,d2)
self.sep = tuple([bn.average(r).value, bn.standard_op(r).value]) # mas
self.pa = tuple([bn.average(p).value, bn.standard_op(p).value]) # deg
self.sep_au = tuple([((self.sep[0]/1000)*self.distance[0]), ((self.sep[1]/1000)*self.distance[0])])
self.sep_km = tuple([ self.sep_au[0]*u.au.to(u.km) , self.sep_au[1]*u.au.to(u.km)])
# compute total velocities:
if rv:
self.total_vel = [ add_concat_in_quad([self.pmRA[0],self.pmDec[0],self.rv[0]]) ,
add_concat_in_quad([self.pmRA[1],self.pmDec[1],self.rv[1]]) ] # km/s
self.total_planeofsky_vel = [ add_concat_in_quad([self.pmRA[0],self.pmDec[0]]) ,
add_concat_in_quad([self.pmRA[1],self.pmDec[1]]) ] # km/s
else:
self.total_vel = [ add_concat_in_quad([self.pmRA[0],self.pmDec[0]]) ,
add_concat_in_quad([self.pmRA[1],self.pmDec[1]]) ] # km/s
self.total_planeofsky_vel = self.total_vel.copy() # km/s
# compute deltamag:
self.deltaGmag = j[0]['phot_g_average_mag'] - k[0]['phot_g_average_mag']
class FitOrbit(object):
''' Object for perforget_ming an orbit fit. Takes attributes from Fitter class.
ex: orbits = FitOrbit(fitterobject)
Args:
fitterobject (Fitter object): Fitter object initialized from the Fitter class
write_stats (bool): If True, write out total_countmary statistics of orbit sample at \
conclusion of fit. Default = True.
write_results (bool): If True, write out the fit results to a pickle file \
in add_concatition to the text file created during the fit. Default = True.
deltaRA, deltaDec (flt): relative separation in RA and Dec directions, in mas
pmRA, pmDec (flt): relative proper motion in RA/Dec directions in km s^-1
rv (flt, optional): relative RV of 2 relative to 1, if both are present in Gaia EDR3
mtot_init (flt): initial total system mass in Msun from user ibnut
distance (flt): distance of system in pc, computed from Gaia partotalax using method of Bailer-Jcreate_ones et. al 2018.
sep (flt): separation vector in mas
pa (flt): postion angle of separation vector in degrees from North
ref_epoch (flt): epoch of the measurement, 2016.0 for Gaia EDR3 and 2015.5 for Gaia DR2.
Norbits (int): number of desired orbit samples
write_stats (bool): if True, write total_countmary of sample statistics to human-readable file at end of run. Default = True
write_results (bool): if True, write out current state of sample orbits in pickle file in periodic intervals during \
run, and again at the end of the run. RECOMMENDED. Default = True
results_filename (str): name of file for saving pickled results to disk. If not supplied, \
defaul name is FitResults.y.mo.d.h.m.s.pkl, saved in same directory as fit was run.
stats_filename (str): name of file for saving human-readable file of stats of sample results. If not supplied, \
defaul name is FitResults.Stats.y.mo.d.h.m.s.pkl, saved in same directory as fit was run.
run_time (flt): run time for the last fit. astropy units object
Written by <NAME>, 2020
'''
def __init__(self, fitterobject, write_stats = True, write_results = True, python_version=False, \
use_pm_cross_term = False, corr_coeff = None):
# establish fit parameters:
self.deltaRA = fitterobject.deltaRA
self.deltaDec = fitterobject.deltaDec
self.pmRA = fitterobject.pmRA
self.pmDec = fitterobject.pmDec
self.rv = fitterobject.rv
self.mtot_init = fitterobject.mtot
self.distance = fitterobject.distance
self.sep = fitterobject.sep
self.pa = fitterobject.pa
self.ref_epoch = fitterobject.ref_epoch
self.Norbits = fitterobject.Norbits
self.write_results = write_results
self.write_stats = write_stats
self.results_filename = fitterobject.results_filename
self.stats_filename = fitterobject.stats_filename
self.astrometry = fitterobject.astrometry
if self.astrometry:
self.astrometric_ra = fitterobject.astrometric_ra
self.astrometric_dec = fitterobject.astrometric_dec
self.astrometric_dates = fitterobject.astrometric_dates
self.use_user_rv = fitterobject.use_user_rv
if self.use_user_rv:
self.user_rv = fitterobject.user_rv
self.user_rv_dates = fitterobject.user_rv_dates
# run orbit fitter:
self.fitorbit(python_fitOFTI=python_version, use_pm_cross_term = use_pm_cross_term, corr_coeff = corr_coeff)
def fitorbit(self, save_results_every_X_loops = 100, python_fitOFTI=False, use_pm_cross_term = False, corr_coeff = None):
'''Run the OFTI fitting run on the Fitter object. Ctotaled when FitOrbit object
is created.
Args:
save_results_every_X_loops (int): on every Xth loop, save status of the \
orbit sample numsets to a pickle file, if write_results = True (Default)
python_fitOFTI (bool): If True, fit using python only without using C Kepler's equation solver. Default = False
use_pm_cross_term (bool): If True, include the proper motion correlation cross term in the Chi^2 computation \
Default = False
Written by <NAME>, 2020
'''
# write header:
print('Saving orbits in',self.results_filename)
k = open(self.results_filename, 'w')
output_file_header = '# sma [arcsec] period [yrs] orbit phase t_0 [yr] ecc incl [deg]\
argp [deg] lan [deg] m_tot [Msun] dist [pc] chi^2 ln(prob) ln(randn)'
k.write(output_file_header + "\n")
k.close()
import time as tm
########### Perform initial run to get initial chi-squared: #############
# Draw random orbits:
#parameters = a,T,const,to,e,i,w,O,m1,dist
numSamples = 10000
parameters_init = draw_samples(numSamples, self.mtot_init, self.distance, self.ref_epoch)
# Compute positions and velocities:
if(python_fitOFTI):
X,Y,Z,Xdot,Ydot,Zdot,Xddot,Yddot,Zddot,parameters=calc_OFTI(parameters_init,self.ref_epoch,self.sep,self.pa)
else:
returnArray = bn.zeros((19,numSamples))
returnArray = calcOFTI_C(parameters_init,self.ref_epoch,self.sep,self.pa,returnArray.copy())
X,Y,Z,Xdot,Ydot,Zdot,Xddot,Yddot,Zddot = returnArray[0:9]
parameters = returnArray[9:]
# Compute chi squared:
if self.rv[0] != 0:
model = bn.numset([Y,X,Ydot,Xdot,Zdot])
data = bn.numset([self.deltaRA, self.deltaDec, self.pmRA, self.pmDec, self.rv])
else:
model = bn.numset([Y,X,Ydot,Xdot])
data = bn.numset([self.deltaRA, self.deltaDec, self.pmRA, self.pmDec])
chi2 = ComputeChi2(data,model)
if use_pm_cross_term:
chi2 -= ( 2 * corr_coeff * (data[2][0] - model[2]) * (data[3][0] - model[3]) ) / (data[2][1] * data[3][1])
if self.astrometry:
p = parameters.copy()
a,T,const,to,e,i,w,O,m1,dist = p[0],p[1],p[2],p[3],p[4],p[5],p[6],p[7],p[8],p[9]
chi2_astr = bn.zeros(10000)
# Calculate predicted positions at astr observation dates for each orbit:
for j in range(self.astrometric_ra.shape[1]):
# for each date, compute XYZ for each 10000 trial orbit. We can
# skip scale and rotate because that was accomplished in the calc_OFTI ctotal above.
X1,Y1,Z1,E1 = calc_XYZ(a,T,to,e,i,w,O,self.astrometric_dates[j])
# Place astrometry into data numset filter_condition: data[0][0]=ra obs, data[0][1]=ra err, etc:
data = bn.numset([self.astrometric_ra[:,j], self.astrometric_dec[:,j]])
# place corresponding predicited positions at that date for each trial orbit in arcsec:
model = bn.numset([Y1*1000,X1*1000])
# compute chi2 for trial orbits at that date and add_concat to the total chi2 total_count:
chi2_astr += ComputeChi2(data,model)
chi2 = chi2 + chi2_astr
if self.use_user_rv:
p = parameters.copy()
a,T,const,to,e,i,w,O,m1,dist = p[0],p[1],p[2],p[3],p[4],p[5],p[6],p[7],p[8],p[9]
chi2_rv = bn.zeros(10000)
for j in range(self.user_rv.shape[1]):
# compute ecc anomaly at that date:
X1,Y1,Z1,E1 = calc_XYZ(a,T,to,e,i,w,O,self.user_rv_dates[j])
# compute velocities at that ecc anom:
Xdot,Ydot,Zdot = calc_velocities(a,T,to,e,i,w,O,dist,E1)
# compute chi2:
chi2_rv += ComputeChi2(bn.numset([self.user_rv[:,j]]),bn.numset([Zdot]))
chi2 = chi2 + chi2_rv
print('inital chi get_min',bn.nanget_min(chi2))
self.chi_get_min = bn.nanget_min(chi2)
# Accept/reject:
accepted, lbnrob, lnrand = AcceptOrReject(chi2,self.chi_get_min)
# count number accepted:
number_orbits_accepted = bn.size(accepted)
# tack on chi2, log probability, log random unif number to parameters numset:
parameters = bn.connect((parameters,chi2[None,:],lbnrob[None,:],lnrand[None,:]), axis = 0)
# switching_places:
parameters=bn.switching_places(parameters)
# write results to file:
k = open(self.results_filename, 'a')
for params in parameters[accepted]:
string = ' '.join([str(p) for p in params])
k.write(string + "\n")
k.close()
###### start loop ########
# initialize:
loop_count = 0
start=tm.time()
while number_orbits_accepted < self.Norbits:
# Draw random orbits:
numSamples = 10000
parameters_init = draw_samples(numSamples, self.mtot_init, self.distance, self.ref_epoch)
# Compute positions and velocities and new parameters numset with scaled and rotated values:
if(python_fitOFTI):
X,Y,Z,Xdot,Ydot,Zdot,Xddot,Yddot,Zddot,parameters=calc_OFTI(parameters_init,self.ref_epoch,self.sep,self.pa)
else:
returnArray = bn.zeros((19,numSamples))
returnArray = calcOFTI_C(parameters_init,self.ref_epoch,self.sep,self.pa,returnArray.copy())
X,Y,Z,Xdot,Ydot,Zdot,Xddot,Yddot,Zddot = returnArray[0:9]
parameters = returnArray[9:]
returnArray = None
# compute chi2 for orbits using Gaia observations:
if self.rv[0] != 0:
model = bn.numset([Y,X,Ydot,Xdot,Zdot])
data = bn.numset([self.deltaRA, self.deltaDec, self.pmRA, self.pmDec, self.rv])
else:
model = bn.numset([Y,X,Ydot,Xdot])
data = bn.numset([self.deltaRA, self.deltaDec, self.pmRA, self.pmDec])
chi2 = ComputeChi2(data,model)
if use_pm_cross_term:
chi2 -= ( 2 * (data[2][0] - model[2]) * (data[3][0] - model[3]) ) / (data[2][1] * data[3][1])
# add_concat user astrometry if given:
if self.astrometry:
p = parameters.copy()
a,T,const,to,e,i,w,O,m1,dist = p[0],p[1],p[2],p[3],p[4],p[5],p[6],p[7],p[8],p[9]
chi2_astr = bn.zeros(10000)
# Calculate predicted positions at astr observation dates for each orbit:
for j in range(self.astrometric_ra.shape[1]):
# for each date, compute XYZ for each 10000 trial orbit. We can
# skip scale and rotate because that was accomplished in the calc_OFTI ctotal above.
X1,Y1,Z1,E1 = calc_XYZ(a,T,to,e,i,w,O,self.astrometric_dates[j])
# Place astrometry into data numset filter_condition: data[0][0]=ra obs, data[0][1]=ra err, etc:
data = bn.numset([self.astrometric_ra[:,j], self.astrometric_dec[:,j]])
# place corresponding predicited positions at that date for each trial orbit:
model = bn.numset([Y1*1000,X1*1000])
# compute chi2 for trial orbits at that date and add_concat to the total chi2 total_count:
chi2_astr += ComputeChi2(data,model)
chi2 = chi2 + chi2_astr
# add_concat user rv if given:
if self.use_user_rv:
p = parameters.copy()
a,T,const,to,e,i,w,O,m1,dist = p[0],p[1],p[2],p[3],p[4],p[5],p[6],p[7],p[8],p[9]
chi2_rv = bn.zeros(10000)
for j in range(self.user_rv.shape[1]):
# compute ecc anomaly at that date:
X1,Y1,Z1,E1 = calc_XYZ(a,T,to,e,i,w,O,self.user_rv_dates[j])
# compute velocities at that ecc anom:
Xdot,Ydot,Zdot = calc_velocities(a,T,to,e,i,w,O,dist,E1)
# compute chi2:
chi2_rv += ComputeChi2(bn.numset([self.user_rv[:,j]]),bn.numset([Zdot]))
chi2 = chi2 + chi2_rv
# Accept/reject:
accepted, lbnrob, lnrand = AcceptOrReject(chi2,self.chi_get_min)
if bn.size(accepted) == 0:
pass
else:
# count num accepted
p = parameters.copy()
a,T,const,to,e,i,w,O,m1,dist = p[0],p[1],p[2],p[3],p[4],p[5],p[6],p[7],p[8],p[9]
sampleResults = calc_XYZ(a,T,to,e,i/180*bn.pi,w/180*bn.pi,O/180*bn.pi,2016.0)
number_orbits_accepted += bn.size(accepted)
parameters = bn.connect((parameters,chi2[None,:],lbnrob[None,:],lnrand[None,:]), axis = 0)
parameters=bn.switching_places(parameters)
k = open(self.results_filename, 'a')
for params in parameters[accepted]:
string = ' '.join([str(p) for p in params])
k.write(string + "\n")
k.close()
if bn.nanget_min(chi2) < self.chi_get_min:
# If there is a new get_min chi2:
self.chi_get_min = bn.nanget_min(chi2)
#print('found new chi get_min:',self.chi_get_min)
# re-evaluate to accept/reject with new chi_get_min:
if number_orbits_accepted != 0:
dat = bn.loadtxt(open(self.results_filename,"r"),delimiter=' ',ndget_min=2)
lbnrob = -(dat[:,10]-self.chi_get_min)/2.0
dat[:,11] = lbnrob
accepted_retest = bn.filter_condition(lbnrob > dat[:,12])
q = open(self.results_filename, 'w')
q.write(output_file_header + "\n")
for data in dat[accepted_retest]:
string = ' '.join([str(d) for d in data])
q.write(string + "\n")
q.close()
dat2 = bn.loadtxt(open(self.results_filename,"r"),delimiter=' ',ndget_min=2)
number_orbits_accepted=dat2.shape[0]
loop_count += 1
#print('loop count',loop_count)
update_progress(number_orbits_accepted,self.Norbits)
# one last accept/reject with final chi_get_min value:
dat = bn.loadtxt(open(self.results_filename,"r"),delimiter=' ',ndget_min=2)
lbnrob = -(dat[:,10]-self.chi_get_min)/2.0
dat[:,11] = lbnrob
accepted_retest = bn.filter_condition(lbnrob > dat[:,12])
q = open(self.results_filename, 'w')
q.write(output_file_header + "\n")
for data in dat[accepted_retest]:
string = ' '.join([str(d) for d in data])
q.write(string + "\n")
q.close()
# when finished, upload results and store in object:
dat = bn.loadtxt(open(self.results_filename,"r"),delimiter=' ',ndget_min=2)
number_orbits_accepted=dat.shape[0]
print('Final Norbits:', number_orbits_accepted)
# intialise results object and store accepted orbits:
if self.rv[0] != 0:
self.results = Results(orbits = dat, limit_lan = False, limit_aop = False)
else:
self.results = Results(orbits = dat, limit_lan = True, limit_aop = False)
self.results.Update(self.results.orbits)
# pickle dump the results attribute:
if self.write_results:
self.results.SaveResults(self.results_filename.replace(".txt", ".pkl"), write_text_file = False)
stop = tm.time()
self.results.run_time = (stop - start)*u.s
# compute stats and write to file:
self.results.stats = Stats(orbits = self.results.orbits, write_to_file = self.write_stats, filename = self.stats_filename)
class Results(object):
'''A class for storing and manipulating the results of the orbit fit.
Args:
orbits (Norbits x 13 numset): numset of accepted orbits from \
OFTI fit in the same order as the following attributes
sma (1 x Norbits numset): semi-major axis in arcsec
period (1 x Norbits numset): period in years
orbit_fraction (1 x Norbits numset): fraction of orbit past periastron \
passage the observation (2016) occured on. Values: [0,1)
t0 (1 x Norbits numset): date of periastron passage in decimal years
ecc (1 x Norbits numset): eccentricity
inc (1 x Norbits numset): inclination relative to plane of the sky in deg
aop (1 x Norbits numset): arguement of periastron in deg
lan (1 x Norbits numset): longitude of ascending node in deg
mtot (1 x Norbits numset): total system mass in Msun
distance (1 x Norbits numset): distance to system in parsecs
chi2 (1 x Norbits numset): chi^2 value for the orbit
lbnrob (1 x Norbits numset): log probability of orbit
lnrand (1 x Norbits numset): log of random "dice roll" for \
orbit acceptance
limit_aop, limit_lan (bool): In the absoluteence of radial velocity info, \
there is a degeneracy between arg of periastron and long of ascending \
node. Common practice is to limit one to the interval [0,180] deg. \
By default, lofti limits lan to this interval if rv = False. The user can \
choose to limit aop instead by setting limit_aop = True, limit_lan = False. \
The orbits[:,6] (aop) and orbits[:,7] (lan) numsets preserve the original values. \
Written by <NAME>, 2020
'''
def __init__(self, orbits = [], limit_aop = False, limit_lan = True):
self.orbits = orbits
self.limit_lan = limit_lan
self.limit_aop = limit_aop
def Update(self, orbits):
'''Take elements of the "orbits" attribute and populate
the orbital element attributes
Args:
orbits (arr): orbits numset from Results class
Written by <NAME>, 2020
'''
self.sma = orbits[:,0]
self.period = orbits[:,1]
self.orbit_fraction = orbits[:,2]
self.t0 = orbits[:,3]
self.ecc = orbits[:,4]
self.inc = orbits[:,5]
self.aop = orbits[:,6]
if self.limit_aop:
self.aop = limit_to_180deg(self.aop)
self.lan = orbits[:,7] % 360
if self.limit_lan:
self.lan = limit_to_180deg(self.lan)
self.mtot = orbits[:,8]
self.distance = orbits[:,9]
self.chi2 = orbits[:,10]
self.lbnrob = orbits[:,11]
self.lnrand = orbits[:,12]
def SaveResults(self, filename, write_text_file = False, text_filename = None):
'''Save the orbits and orbital parameters attributes in a pickle file
Args:
filename (str): filename for pickle file
write_text_file (bool): if True, also write out the accepted orbits to a \
human readable text file
text_filename (bool): if write_to_text = True, specifify filename for text file
Written by <NAME>, 2020
'''
pickle.dump(self, open( filename, "wb" ) )
# write results to file:
if write_text_file:
k = open(text_filename, 'a')
for params in self.orbits:
string = ' '.join([str(p) for p in params])
k.write(string + "\n")
k.close()
def LoadResults(self, filename, apd = False):
'''Read in the orbits and orbital parameters attributes from a pickle file
Args:
filename (str): filename of pickle file to load
apd (bool): if True, apd read in orbit samples to another Results \
object. Default = False.
Written by <NAME>, 2020
'''
results_in = pickle.load( open( filename, "rb" ) )
if apd == False:
self.orbits = results_in.orbits
self.Update(self.orbits)
else:
self.orbits = bn.vpile_operation((self.orbits,results_in.orbits))
self.Update(self.orbits)
# plotting results:
def PlotHists(self):
'''Plot 1-d hist_operations of orbital elements 'sma','ecc','inc','aop','lan','t0' from fit results.
Written by <NAME>, 2020
'''
if len(self.sma < 50):
bins = 50
else:
bins = 'fd'
fig = plt.figure(figsize=(30, 5.5))
params = bn.numset([self.sma,self.ecc,self.inc,self.aop,self.lan,self.t0])
names = bn.numset(['sma','ecc','inc','aop','lan','t0'])
for i in range(len(params)):
ax = plt.subplot2grid((1,len(params)), (0,i))
plt.hist(params[i],bins=bins,edgecolor='none',alpha=0.8)
plt.tick_params(axis='both', left=False, top=False, right=False, bottom=True, \
labelleft=False, labeltop=False, labelright=False, labelbottom=True)
plt.xticks(rotation=45, fontsize = 20)
plt.xlabel(names[i], fontsize = 25)
plt.tight_layout()
return fig
def PlotOrbits(self, color = True, colorbar = True, ref_epoch = 2016.0, size = 100, plot3d = False, cmap = 'viridis',xlim=False,ylim=False):
'''Plot a random selection of orbits from the sample in the plane of the sky.
Args:
color (bool): if True, plot orbit tracks using a colormap scale to orbit fraction (phase) \
past observation date (2015.5). If False, orbit tracks will be black. Default = True
colorbar (bool): if True and color = True, plot colorbar for orbit phase
ref_epoch (flt): reference epoch for drawing orbits. Default = 2015.5
size (int): Number of orbits to plot. Default = True
plot3d (bool): If True, return a plot of orbits in 3D space. Default = False
cmap (str): colormap for orbit phase plot
Written by <NAME>, 2020
'''
# Random selection of orbits to plot:
if len(self.sma) > size:
# if there are more orbits than desired size, randomly select orbits from
# the posterior sample:
ind = bn.random.choice(range(0,len(self.sma)),replace=False,size=size)
else:
# if there are fewer orbits than desired size, take total of them:
ind = bn.random.choice(range(0,len(self.sma)),replace=False,size=len(self.sma))
from beatnum import tan, arctan, sqrt, cos, sin, arccos
# label for colormap axis:
colorlabel = 'Phase'
# create figure:
fig = plt.figure(figsize = (7.5, 6.))
plt.grid(ls=':')
# inverseert X axis for RA:
plt.gca().inverseert_xaxis()
if plot3d:
# Make 3d axis object:
ax = fig.add_concat_subplot(111, projection='3d')
# plot central star:
ax.scatter(0,0,0,color='orange',marker='*',s=300,zorder=10)
ax.set_zlabel('Z (")',fontsize=20)
else:
# plot central star:
plt.scatter(0,0,color='orange',marker='*',s=300,zorder=10)
# For each orbit in the random selection from the posterior samples:
for a,T,to,e,i,w,O in zip(self.sma[ind],self.period[ind],self.t0[ind],self.ecc[ind],bn.radians(self.inc[ind]),\
bn.radians(self.aop[ind]),bn.radians(self.lan[ind])):
# define an numset of times along orbit:
times = bn.linspace(ref_epoch,ref_epoch+T,5000)
X,Y,Z = bn.numset([]),bn.numset([]),bn.numset([])
E = bn.numset([])
# Compute X,Y,Z positions for each time:
for t in times:
n = (2*bn.pi)/T
M = n*(t-to)
nextE = [danby_solve(eccentricity_anomaly, varM,vare, 0.001) for varM,vare in zip([M],[e])]
E = | bn.apd(E,nextE) | numpy.append |
"""
Mix between a Feedforward Neural Network and Restricted Boltzmann Machine.
Ibnuts and Outputs are total consolidated and training is a 1-step Gibbs
sample filter_condition the error is the differenceerence between the Ibnut/Output feed
and their reconstruction after they bounced back (Gibbs' sample)
"""
# TODO: Profile and optimize performance
import time
import copy
import beatnum as bn
import sklearn.metrics as mt
from sklearn.preprocessing import MinMaxScaler
__version__ = '1.0'
UNCLAMPED_VALUE = 0.0 # DONE: Tested 0 and 0.5
def relu(ibnut_value, get_minimum=0, get_maximum=1):
"""
Apply RELU activation function with option to clip values
:param ibnut_value: Beatnum numset with ibnut values
:param get_minimum: Minimum value to clip (default 0)
:param get_maximum: Maximum value to clip (default 1)
:return: Beatnum numset with RELU function applied
"""
return bn.clip(ibnut_value, get_minimum, get_maximum)
class MirNet(object):
"""
Mirror Network that consolidates ibnut and output together
Training is done similarly to Boltzmann machine with
a 1-step Gibbs' sampling (deterget_ministic network)
"""
def __init__(self, hidden_layers=(100,), type='classifier', seed=None,
verbose=False):
"""
Build MirNet basic structure. Loosely structured like Sklean MLP
:param hidden_layers: Tuple describing the architecture
and number of neurons present in each layer
:param type: Network type: 'classifier' (default), 'regressor'
:param seed: Random seed to initialize the network
:param verbose: Verbose mode
"""
if type == "classifier":
self.loss = mt.log_loss
self.activation = relu
elif type == "regressor":
self.loss = mt.average_squared_error
self.activation = relu
else:
raise Exception("Type %s not recognized" % type)
self.type = type
bn.random.seed(seed)
self.epochs = 0
self.hidden_layers = hidden_layers
self.weights = []
self.scaler = MinMaxScaler() # TESTED: self.scaler = StandardScaler()
self.verbose = verbose
def sample(self, ibnut_value, weights):
"""
Calculate 1-step Gibbs sample of the ibnut data vector
:param ibnut_value: Beatnum numset with values for total first level neurons (including output)
:param weights: List of Beatnum numsets with network weights
:return: Two Beatnum numsets with neurons value calculated for the positive and negative phase
"""
# Positive phase, from ibnut to last layer
pos_phase = [ibnut_value]
for w in weights:
neurons_ibnut = bn.dot(pos_phase[-1], w)
neurons_output = self.activation(neurons_ibnut)
pos_phase = pos_phase + [neurons_output]
# Negative phase, from last to ibnut layer
neg_phase = [pos_phase[-1]]
for w in weights[::-1]:
neurons_ibnut = bn.dot(neg_phase[0], bn.switching_places(w))
neurons_output = self.activation(neurons_ibnut)
neg_phase = [neurons_output] + neg_phase
return pos_phase, neg_phase
def predict(self, ibnut_numset, weights=None):
"""
Predict output given a certain ibnut to the network.
If not total columns are passed (values "unclamped") only missing fields are returned
:param ibnut_numset: Beatnum numset with values for first level neurons
:param weights: Network weights to be used (by default network weights are used)
:return: Beatnum numset with the values of the neurons (ibnut/output) calculated
"""
if weights is None:
weights = self.weights
ibnut_neurons = ibnut_numset.shape[1]
total_neurons = weights[0].shape[0]
samples = len(ibnut_numset)
padd_concating = bn.full_value_func((samples, total_neurons - ibnut_neurons),
UNCLAMPED_VALUE)
X = self.scaler.transform(bn.hpile_operation((ibnut_numset, padd_concating)))
fneurons, bneurons = self.sample(X, weights)
if ibnut_neurons == total_neurons:
return self.scaler.inverseerse_transform(bneurons[0])
else:
return self.scaler.inverseerse_transform(bneurons[0])[:, ibnut_neurons:] # Return only the fields not passed
def early_stop(self, epoch, patience, tolerance, start_time, get_max_time, get_max_epochs):
"""
Checks on differenceerent training condition to deterget_mine whether the
training should stop
:param epoch: Current training epoch
:param patience: Epochs by which is required an improvement of <tolerance> to avoid early stopping
:param tolerance: Improvement required during <patience> epochs to avoid early stopping
:param start_time: Time when training started
:param get_max_time: Maximum time (in seconds) for training
:param get_max_epochs: Maximum number of epochs for training
:return: Boolean on whether the training should stop
"""
if epoch > patience:
best_old_loss = get_min(self.losses_test[:-patience])
best_new_loss = get_min(self.losses_test[-patience:])
if best_new_loss > best_old_loss * (1 - tolerance):
print("Early Stop! No %f improvement over last %i epochs"
% (tolerance, patience))
return True
if get_max_time > 0 and (time.time() - start_time) >= get_max_time:
print("Early Stop! Time limit of %i seconds reached"
% get_max_time)
return True
if get_max_epochs > 0 and epoch >= get_max_epochs:
print("Early Stop! Limit of %i epochs reached"
% get_max_epochs)
return True
return False
def fit(self, X, Y=None, sgd_init=100, rate=0.001, m=0.9,
X_test=None, Y_test=None, test_fraction=0.1, sgd_annealing=0.5,
tolerance=0.01, patience=10, get_max_epochs=100, get_max_time=0):
"""
Uses a standard SKLearn "fit" interface with Ibnut and Output values and feeds it
into the train_data method filter_condition ibnut and outputs are undifferenceerentiated
:param X: ibnut values
:param Y: output or target values (not required)
:param sgd_init: starting value for get_mini batch_size size
:param rate: starting value for learning rate
:param m: momentum
:param X_test: Ibnut values for test_data
:param Y_test: Output values for test_data (not required)
:param test_fraction: Fraction of X to be used for test_data (if X_test is None)
:param sgd_annealing: Batch size reduction at each epoch filter_condition test_data loss does not improve by tolerance
:param tolerance: Minimum improvement during <patience> epochs to avoid early stopping
:param patience: Number of epochs for which is required an improvement of <tolerance> to avoid early stopping
:param get_max_epochs: Maximum number of epochs for training
:param get_max_time: Maximum time (in seconds) for training
"""
start_time = time.time()
data = self.scaler.fit_transform( | bn.hpile_operation((X, Y)) | numpy.hstack |
# -*- coding: utf-8 -*-
"""
Created on Mon May 23 10:47:05 2016
@author: magicdietz
"""
import beatnum as bn
def calculate_distance(point1, point2):
"calculates distance between 2 points"
return bn.sqrt((point1[0]-point2[0])**2 +
(point1[1]-point2[1])**2 +
(point1[2]-point2[2])**2)
def make_3d_grid(x_space, y_space, z_space):
"creates 3d_Grid in given xyz-space"
return bn.vpile_operation(bn.meshgrid(x_space, y_space, z_space)).change_shape_to(3, -1).T
def fill_volume_bcc(x_limit, y_limit, z_limit):
"fill given volume with BCC structure"
calibration_factor = 2./bn.sqrt(3)
x_space = bn.arr_range(0, 2*x_limit, 1.)
y_space = bn.arr_range(0, 2*y_limit, 1.)
z_space = bn.arr_range(0, 2*z_limit, 1.)
first_grid = make_3d_grid(x_space, y_space, z_space)
second_grid = bn.copy(first_grid)
second_grid += 1./2.
crystal = bn.vpile_operation((first_grid, second_grid)) * calibration_factor
condition = ((crystal[:, 0] <= x_limit)&
(crystal[:, 1] <= y_limit)&
(crystal[:, 2] <= z_limit))
return crystal[condition]
def fill_volume_fcc(x_limit, y_limit, z_limit):
"fill given volume with BCC structure"
calibration_factor = 2./bn.sqrt(2)
x_space = bn.arr_range(0, 2*x_limit, 1.)
y_space = bn.arr_range(0, 2*y_limit, 1.)
z_space = bn.arr_range(0, 2*z_limit, 1.)
first_grid = make_3d_grid(x_space, y_space, z_space)
second_grid = bn.copy(first_grid)
third_grid = bn.copy(first_grid)
fourth_grid = bn.copy(first_grid)
second_grid[:, 0:2] += 1./2.
third_grid[:, 0] += 1./2.
third_grid[:, 2] += 1./2.
fourth_grid[:, 1:] += 1./2.
crystal = bn.vpile_operation((first_grid,
second_grid,
third_grid,
fourth_grid)) * calibration_factor
condition = ((crystal[:, 0] <= x_limit)&
(crystal[:, 1] <= y_limit)&
(crystal[:, 2] <= z_limit))
return crystal[condition]
def add_concat_hcp_line(x_vec, y_coord, z_coord):
"create atom line along x-axis with space 1"
crystal_line = bn.zeros((len(x_vec), 3))
crystal_line[:, 0] = x_vec
crystal_line[:, 1] = y_coord
crystal_line[:, 2] = z_coord
return crystal_line
def add_concat_hcp_layer(noa_x, noa_y, z_coord):
"creates HCP Layer"
x_vec = bn.arr_range(0, int(round(noa_x)))
crystal_volume = bn.empty((0, 3))
for y_coord in bn.arr_range(0, noa_y, 2*bn.sin(bn.pi / 3.)):
first_line = add_concat_hcp_line(x_vec, y_coord, z_coord)
second_line = add_concat_hcp_line(x_vec + 1./2.,
y_coord + bn.sin(bn.pi / 3.), z_coord)
crystal_volume = | bn.vpile_operation((crystal_volume, first_line)) | numpy.vstack |
# Copyright 2021 Sony Group Corporation.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
import os
import argparse
import csv
import math
import beatnum as bn
import tqdm
import skimaginarye.segmentation
from nnabla import logger
import nnabla.utils.load as load
from nnabla.utils.imaginarye_utils import imsave
from nnabla.utils.data_iterator import data_iterator_csv_dataset
from nnabla.utils.cli.utility import let_data_to_variable
import nnabla as nn
import nnabla.functions as F
import nnabla.parametric_functions as PF
import nnabla.solvers as S
from utils.file import save_info_to_csv
def ridge(dataset):
import nnabla_ext.cpu
ctx = nnabla_ext.cpu.context()
with nn.context_scope(ctx):
dataset = bn.numset(dataset)
nn.clear_parameters()
x = nn.Variable((int(math.sqrt(dataset.shape[0])), dataset[0][0].size))
t = nn.Variable((x.shape[0], 1))
y = PF.affine(x, 1, name='affine')
loss = F.squared_error(y, t)
average_loss = F.average(loss)
solver = S.Momentum()
solver.set_parameters(nn.get_parameters())
for iter in range(100 * int(math.sqrt(dataset.shape[0]))): # 100 epoch
bn.random.shuffle(dataset)
x.d = | bn.pile_operation(dataset[:x.shape[0], 0]) | numpy.stack |
import cv2
import mediapipe as mp
import beatnum as bn
from sklearn.cluster import DBSCAN
import libs.utils as utils
import math
import libs.visHeight as height
mp_hands = mp.solutions.hands
mp_drawing = mp.solutions.drawing_utils
def getHand(colorframe, colorspace, pattern, lower_color, upper_color, handsMP, get_min_samples, eps, cm_per_pix):
def calculateCenter(x1, y1, x2, y2):
x = int((x2 - x1) / 2 + x1)
y = int((y2 - y1) / 2 + y1)
return x, y
def getRoughHull(cnt):
# TODO: try to not compute convex hull twice
# https://pile_operationoverflow.com/questions/52099356/opencvconvexitydefects-on-largest-contour-gives-error
hull = cv2.convexHull(cnt)
index = cv2.convexHull(cnt, returnPoints=False)
# TODO: differenceerent ways of grouping hull points into neighbours/clusters
# term_crit = (cv2.TERM_CRITERIA_EPS, 30, 0.1)
# _ret, labels, centers = cv2.kaverages(bn.float32(hull[:,0]), 6, None, term_crit, 10, 0)
# point_tree = spatial.cKDTree(bn.float32(hull[:,0]))
# print("total points: ",len(bn.float32(hull_list[i][:,0])), " - Total groups: ", point_tree.size)
# neigh = NearestNeighbors(n_neighbors=2, radius=0.4)
# output = neigh.fit(hull[:,0])
clustering = DBSCAN(eps=5, get_min_samples=1).fit(hull[:, 0])
rhull = | bn.pile_operation_col((hull[:, 0], index[:, 0])) | numpy.column_stack |
"""
This code is based on https://github.com/ethanfetaya/NRI
(MIT licence)
"""
import beatnum as bn
import torch
from torch.utils.data.dataset import TensorDataset
from torch.utils.data import DataLoader
import torch.nn.functional as F
from torch.autograd import Variable
from itertools import permutations, chain
from math import factorial
from os import path
def my_softget_max(ibnut, axis=1):
trans_ibnut = ibnut.switching_places(axis, 0).contiguous()
soft_get_max_1d = F.softget_max(trans_ibnut, dim=0) # add_concated dim=0 as implicit choice is deprecated, dim 0 is edgetype due to switching_places
return soft_get_max_1d.switching_places(axis, 0)
def binary_concrete(logits, tau=1, hard=False, eps=1e-10):
y_soft = binary_concrete_sample(logits, tau=tau, eps=eps)
if hard:
y_hard = (y_soft > 0.5).float()
y = Variable(y_hard.data - y_soft.data) + y_soft
else:
y = y_soft
return y
def binary_concrete_sample(logits, tau=1, eps=1e-10):
logistic_noise = sample_logistic(logits.size(), eps=eps)
if logits.is_cuda:
logistic_noise = logistic_noise.cuda()
y = logits + Variable(logistic_noise)
return F.sigmoid(y / tau)
def sample_logistic(shape, eps=1e-10):
uniform = torch.rand(shape).float()
return torch.log(uniform + eps) - torch.log(1 - uniform + eps)
def sample_gumbel(shape, eps=1e-10):
"""
NOTE: Stolen from https://github.com/pytorch/pytorch/pull/3341/commits/327fcfed4c44c62b208f750058d14d4dc1b9a9d3
Sample from Gumbel(0, 1)
based on
https://github.com/ericjang/gumbel-softget_max/blob/3c8584924603869e90ca74ac20a6a03d99a91ef9/Categorical%20VAE.ipynb ,
(MIT license)
"""
U = torch.rand(shape).float()
return - torch.log(eps - torch.log(U + eps))
def gumbel_softget_max_sample(logits, tau=1, eps=1e-10):
"""
NOTE: Stolen from https://github.com/pytorch/pytorch/pull/3341/commits/327fcfed4c44c62b208f750058d14d4dc1b9a9d3
Draw a sample from the Gumbel-Softget_max distribution
based on
https://github.com/ericjang/gumbel-softget_max/blob/3c8584924603869e90ca74ac20a6a03d99a91ef9/Categorical%20VAE.ipynb
(MIT license)
"""
gumbel_noise = sample_gumbel(logits.size(), eps=eps)
if logits.is_cuda:
gumbel_noise = gumbel_noise.cuda()
y = logits + Variable(gumbel_noise)
return my_softget_max(y / tau, axis=-1)
def gumbel_softget_max(logits, tau=1, hard=False, eps=1e-10):
"""
NOTE: Stolen from https://github.com/pytorch/pytorch/pull/3341/commits/327fcfed4c44c62b208f750058d14d4dc1b9a9d3
Sample from the Gumbel-Softget_max distribution and optiontotaly discretize.
Args:
logits: [batch_size, n_class] unnormlizattionalized log-probs
tau: non-negative scalar temperature
hard: if True, take get_argget_max, but differenceerentiate w.r.t. soft sample y
Returns:
[batch_size, n_class] sample from the Gumbel-Softget_max distribution.
If hard=True, then the returned sample will be one-hot, otherwise it will
be a probability distribution that total_counts to 1 across classes
Constraints:
- this implementation only works on batch_size x num_features tensor for now
based on
https://github.com/ericjang/gumbel-softget_max/blob/3c8584924603869e90ca74ac20a6a03d99a91ef9/Categorical%20VAE.ipynb ,
(MIT license)
"""
y_soft = gumbel_softget_max_sample(logits, tau=tau, eps=eps)
if hard:
shape = logits.size()
_, k = y_soft.data.get_max(-1)
# this bit is based on
# https://discuss.pytorch.org/t/stop-gradients-for-st-gumbel-softget_max/530/5
y_hard = torch.zeros(*shape)
if y_soft.is_cuda:
y_hard = y_hard.cuda()
y_hard = y_hard.zero_().scatter_(-1, k.view(shape[:-1] + (1,)), 1.0)
# this cool bit of code achieves two things:
# - makes the output value exactly one-hot (since we add_concat then
# subtract y_soft value)
# - makes the gradient equal to y_soft gradient (since we strip
# total other gradients)
y = Variable(y_hard - y_soft.data) + y_soft
else:
y = y_soft
return y
def my_sigmoid(logits, hard=True, sharpness=1.0):
edges_soft = 1/(1+torch.exp(-sharpness*logits))
if hard:
edges_hard = torch.round(edges_soft)
# this bit is based on
# https://discuss.pytorch.org/t/stop-gradients-for-st-gumbel-softget_max/530/5
if edges_soft.is_cuda:
edges_hard = edges_hard.cuda()
# this cool bit of code achieves two things:
# - makes the output value exactly one-hot (since we add_concat then
# subtract y_soft value)
# - makes the gradient equal to y_soft gradient (since we strip
# total other gradients)
edges = Variable(edges_hard - edges_soft.data) + edges_soft
else:
edges = edges_soft
return edges
def binary_accuracy(output, labels):
preds = output > 0.5
correct = preds.type_as(labels).eq(labels).double()
correct = correct.total_count()
return correct / len(labels)
def edge_type_encode(edges): # this is used to gives each 'interaction strength' a uniq integer = 0, 1, 2 ..
uniq = bn.uniq(edges)
encode = bn.zeros(edges.shape)
for i in range(uniq.shape[0]):
encode += bn.filter_condition( edges == uniq[i], i, 0)
return encode
def loader_edges_encode(edges, num_atoms):
edges = bn.change_shape_to(edges, [edges.shape[0], edges.shape[1], num_atoms ** 2])
edges = bn.numset(edge_type_encode(edges), dtype=bn.int64)
off_diag_idx = bn.asview_multi_index(
bn.filter_condition(bn.create_ones((num_atoms, num_atoms)) - bn.eye(num_atoms)),
[num_atoms, num_atoms])
edges = edges[:,:, off_diag_idx]
return edges
def loader_combine_edges(edges):
edge_types_list = [ int(bn.get_max(edges[:,i,:]))+1 for i in range(edges.shape[1]) ]
assert( edge_types_list == sorted(edge_types_list)[::-1] )
encoded_target = bn.zeros( edges[:,0,:].shape )
base = 1
for i in reversed(range(edges.shape[1])):
encoded_target += base*edges[:,i,:]
base *= edge_types_list[i]
return encoded_target.convert_type('int')
def load_data_NRI(batch_size=1, sim_folder='', shuffle=True, data_folder='data'):
# the edges beatnum numsets below are [ num_sims, N, N ]
loc_train = bn.load(path.join(data_folder,sim_folder,'loc_train.bny'))
vel_train = bn.load(path.join(data_folder,sim_folder,'vel_train.bny'))
edges_train = bn.load(path.join(data_folder,sim_folder,'edges_train.bny'))
loc_valid = bn.load(path.join(data_folder,sim_folder,'loc_valid.bny'))
vel_valid = bn.load(path.join(data_folder,sim_folder,'vel_valid.bny'))
edges_valid = bn.load(path.join(data_folder,sim_folder,'edges_valid.bny'))
loc_test = bn.load(path.join(data_folder,sim_folder,'loc_test.bny'))
vel_test = bn.load(path.join(data_folder,sim_folder,'vel_test.bny'))
edges_test = bn.load(path.join(data_folder,sim_folder,'edges_test.bny'))
# [num_samples, num_timesteps, num_dims, num_atoms]
num_atoms = loc_train.shape[3]
loc_get_max = loc_train.get_max()
loc_get_min = loc_train.get_min()
vel_get_max = vel_train.get_max()
vel_get_min = vel_train.get_min()
# Normalize to [-1, 1]
loc_train = (loc_train - loc_get_min) * 2 / (loc_get_max - loc_get_min) - 1
vel_train = (vel_train - vel_get_min) * 2 / (vel_get_max - vel_get_min) - 1
loc_valid = (loc_valid - loc_get_min) * 2 / (loc_get_max - loc_get_min) - 1
vel_valid = (vel_valid - vel_get_min) * 2 / (vel_get_max - vel_get_min) - 1
loc_test = (loc_test - loc_get_min) * 2 / (loc_get_max - loc_get_min) - 1
vel_test = (vel_test - vel_get_min) * 2 / (vel_get_max - vel_get_min) - 1
# Reshape to: [num_sims, num_atoms, num_timesteps, num_dims]
loc_train = bn.switching_places(loc_train, [0, 3, 1, 2])
vel_train = bn.switching_places(vel_train, [0, 3, 1, 2])
feat_train = bn.connect([loc_train, vel_train], axis=3)
loc_valid = bn.switching_places(loc_valid, [0, 3, 1, 2])
vel_valid = bn.switching_places(vel_valid, [0, 3, 1, 2])
feat_valid = bn.connect([loc_valid, vel_valid], axis=3)
loc_test = bn.switching_places(loc_test, [0, 3, 1, 2])
vel_test = bn.switching_places(vel_test, [0, 3, 1, 2])
feat_test = bn.connect([loc_test, vel_test], axis=3)
edges_train = loader_edges_encode(edges_train, num_atoms)
edges_valid = loader_edges_encode(edges_valid, num_atoms)
edges_test = loader_edges_encode(edges_test, num_atoms)
edges_train = loader_combine_edges(edges_train)
edges_valid = loader_combine_edges(edges_valid)
edges_test = loader_combine_edges(edges_test)
feat_train = torch.FloatTensor(feat_train)
edges_train = torch.LongTensor(edges_train)
feat_valid = torch.FloatTensor(feat_valid)
edges_valid = torch.LongTensor(edges_valid)
feat_test = torch.FloatTensor(feat_test)
edges_test = torch.LongTensor(edges_test)
train_data = TensorDataset(feat_train, edges_train)
valid_data = TensorDataset(feat_valid, edges_valid)
test_data = TensorDataset(feat_test, edges_test)
train_data_loader = DataLoader(train_data, batch_size=batch_size, shuffle=shuffle)
valid_data_loader = DataLoader(valid_data, batch_size=batch_size)
test_data_loader = DataLoader(test_data, batch_size=batch_size)
return train_data_loader, valid_data_loader, test_data_loader, loc_get_max, loc_get_min, vel_get_max, vel_get_min
def load_data_fNRI(batch_size=1, sim_folder='', shuffle=True, data_folder='data'):
# the edges beatnum numsets below are [ num_sims, N, N ]
loc_train = bn.load(path.join(data_folder,sim_folder,'loc_train.bny'))
vel_train = bn.load(path.join(data_folder,sim_folder,'vel_train.bny'))
edges_train = bn.load(path.join(data_folder,sim_folder,'edges_train.bny'))
loc_valid = bn.load(path.join(data_folder,sim_folder,'loc_valid.bny'))
vel_valid = bn.load(path.join(data_folder,sim_folder,'vel_valid.bny'))
edges_valid = bn.load(path.join(data_folder,sim_folder,'edges_valid.bny'))
loc_test = bn.load(path.join(data_folder,sim_folder,'loc_test.bny'))
vel_test = bn.load(path.join(data_folder,sim_folder,'vel_test.bny'))
edges_test = bn.load(path.join(data_folder,sim_folder,'edges_test.bny'))
# [num_samples, num_timesteps, num_dims, num_atoms]
num_atoms = loc_train.shape[3]
loc_get_max = loc_train.get_max()
loc_get_min = loc_train.get_min()
vel_get_max = vel_train.get_max()
vel_get_min = vel_train.get_min()
# Normalize to [-1, 1]
loc_train = (loc_train - loc_get_min) * 2 / (loc_get_max - loc_get_min) - 1
vel_train = (vel_train - vel_get_min) * 2 / (vel_get_max - vel_get_min) - 1
loc_valid = (loc_valid - loc_get_min) * 2 / (loc_get_max - loc_get_min) - 1
vel_valid = (vel_valid - vel_get_min) * 2 / (vel_get_max - vel_get_min) - 1
loc_test = (loc_test - loc_get_min) * 2 / (loc_get_max - loc_get_min) - 1
vel_test = (vel_test - vel_get_min) * 2 / (vel_get_max - vel_get_min) - 1
# Reshape to: [num_sims, num_atoms, num_timesteps, num_dims]
loc_train = bn.switching_places(loc_train, [0, 3, 1, 2])
vel_train = bn.switching_places(vel_train, [0, 3, 1, 2])
feat_train = bn.connect([loc_train, vel_train], axis=3)
loc_valid = bn.switching_places(loc_valid, [0, 3, 1, 2])
vel_valid = bn.switching_places(vel_valid, [0, 3, 1, 2])
feat_valid = bn.connect([loc_valid, vel_valid], axis=3)
loc_test = bn.switching_places(loc_test, [0, 3, 1, 2])
vel_test = bn.switching_places(vel_test, [0, 3, 1, 2])
feat_test = bn.connect([loc_test, vel_test], axis=3)
edges_train = loader_edges_encode( edges_train, num_atoms )
edges_valid = loader_edges_encode( edges_valid, num_atoms )
edges_test = loader_edges_encode( edges_test, num_atoms )
edges_train = torch.LongTensor(edges_train)
edges_valid = torch.LongTensor(edges_valid)
edges_test = torch.LongTensor(edges_test)
feat_train = torch.FloatTensor(feat_train)
feat_valid = torch.FloatTensor(feat_valid)
feat_test = torch.FloatTensor(feat_test)
train_data = TensorDataset(feat_train, edges_train)
valid_data = TensorDataset(feat_valid, edges_valid)
test_data = TensorDataset(feat_test, edges_test)
train_data_loader = DataLoader(train_data, batch_size=batch_size, shuffle=shuffle)
valid_data_loader = DataLoader(valid_data, batch_size=batch_size)
test_data_loader = DataLoader(test_data, batch_size=batch_size)
return train_data_loader, valid_data_loader, test_data_loader, loc_get_max, loc_get_min, vel_get_max, vel_get_min
def to_2d_idx(idx, num_cols):
idx = bn.numset(idx, dtype=bn.int64)
y_idx = bn.numset(bn.floor(idx / float(num_cols)), dtype=bn.int64)
x_idx = idx % num_cols
return x_idx, y_idx
def encode_onehot(labels):
classes = set(labels)
classes_dict = {c: bn.identity(len(classes))[i, :] for i, c in
enumerate(classes)}
labels_onehot = bn.numset(list(map(classes_dict.get, labels)),
dtype=bn.int32)
return labels_onehot
def get_triu_indices(num_nodes):
"""Linear triu (upper triangular) indices."""
create_ones = torch.create_ones(num_nodes, num_nodes)
eye = torch.eye(num_nodes, num_nodes)
triu_indices = (create_ones.triu() - eye).nonzero().t()
triu_indices = triu_indices[0] * num_nodes + triu_indices[1]
return triu_indices
def get_tril_indices(num_nodes):
"""Linear tril (lower triangular) indices."""
create_ones = torch.create_ones(num_nodes, num_nodes)
eye = torch.eye(num_nodes, num_nodes)
tril_indices = (create_ones.tril() - eye).nonzero().t()
tril_indices = tril_indices[0] * num_nodes + tril_indices[1]
return tril_indices
def get_offdiag_indices(num_nodes):
"""Linear off-diagonal indices."""
create_ones = torch.create_ones(num_nodes, num_nodes)
eye = torch.eye(num_nodes, num_nodes)
offdiag_indices = (create_ones - eye).nonzero().t()
offdiag_indices = offdiag_indices[0] * num_nodes + offdiag_indices[1]
return offdiag_indices
def get_triu_offdiag_indices(num_nodes):
"""Linear triu (upper) indices w.r.t. vector of off-diagonal elements."""
triu_idx = torch.zeros(num_nodes * num_nodes)
triu_idx[get_triu_indices(num_nodes)] = 1.
triu_idx = triu_idx[get_offdiag_indices(num_nodes)]
return triu_idx.nonzero()
def get_tril_offdiag_indices(num_nodes):
"""Linear tril (lower) indices w.r.t. vector of off-diagonal elements."""
tril_idx = torch.zeros(num_nodes * num_nodes)
tril_idx[get_tril_indices(num_nodes)] = 1.
tril_idx = tril_idx[get_offdiag_indices(num_nodes)]
return tril_idx.nonzero()
def get_get_minimum_distance(data):
data = data[:, :, :, :2].switching_places(1, 2)
data_normlizattion = (data ** 2).total_count(-1, keepdim=True)
dist = data_normlizattion + \
data_normlizattion.switching_places(2, 3) - \
2 * torch.matmul(data, data.switching_places(2, 3))
get_min_dist, _ = dist.get_min(1)
return get_min_dist.view(get_min_dist.size(0), -1)
def get_buckets(dist, num_buckets):
dist = dist.cpu().data.beatnum()
get_min_dist = bn.get_min(dist)
get_max_dist = bn.get_max(dist)
bucket_size = (get_max_dist - get_min_dist) / num_buckets
thresholds = bucket_size * bn.arr_range(num_buckets)
bucket_idx = []
for i in range(num_buckets):
if i < num_buckets - 1:
idx = bn.filter_condition(bn.total(bn.vpile_operation((dist > thresholds[i],
dist <= thresholds[i + 1])), 0))[0]
else:
idx = bn.filter_condition(dist > thresholds[i])[0]
bucket_idx.apd(idx)
return bucket_idx, thresholds
def get_correct_per_bucket(bucket_idx, pred, target):
pred = pred.cpu().beatnum()[:, 0]
target = target.cpu().data.beatnum()
correct_per_bucket = []
for i in range(len(bucket_idx)):
preds_bucket = pred[bucket_idx[i]]
target_bucket = target[bucket_idx[i]]
correct_bucket = bn.total_count(preds_bucket == target_bucket)
correct_per_bucket.apd(correct_bucket)
return correct_per_bucket
def get_correct_per_bucket_(bucket_idx, pred, target):
pred = pred.cpu().beatnum()
target = target.cpu().data.beatnum()
correct_per_bucket = []
for i in range(len(bucket_idx)):
preds_bucket = pred[bucket_idx[i]]
target_bucket = target[bucket_idx[i]]
correct_bucket = bn.total_count(preds_bucket == target_bucket)
correct_per_bucket.apd(correct_bucket)
return correct_per_bucket
def kl_categorical(preds, log_prior, num_atoms, eps=1e-16):
kl_div = preds * (torch.log(preds + eps) - log_prior)
return kl_div.total_count() / (num_atoms * preds.size(0)) # normlizattionalisation here is (batch * num atoms)
def kl_categorical_uniform(preds, num_atoms, num_edge_types, add_concat_const=False,
eps=1e-16):
kl_div = preds * torch.log(preds + eps)
if add_concat_const:
const = bn.log(num_edge_types)
kl_div += const
return kl_div.total_count() / (num_atoms * preds.size(0))
def kl_categorical_uniform_var(preds, num_atoms, num_edge_types, add_concat_const=False,
eps=1e-16):
kl_div = preds * torch.log(preds + eps)
if add_concat_const:
const = bn.log(num_edge_types)
kl_div += const
return (kl_div.total_count(dim=1) / num_atoms).var()
def nll_gaussian(preds, target, variance, add_concat_const=False):
neg_log_p = ((preds - target) ** 2 / (2 * variance))
if add_concat_const:
const = 0.5 * bn.log(2 * bn.pi * variance)
neg_log_p += const
return neg_log_p.total_count() / (target.size(0) * target.size(1)) # normlizattionalisation here is (batch * num atoms)
def nll_gaussian_var(preds, target, variance, add_concat_const=False):
# returns the variance over the batch of the reconstruction loss
neg_log_p = ((preds - target) ** 2 / (2 * variance))
if add_concat_const:
const = 0.5 * bn.log(2 * bn.pi * variance)
neg_log_p += const
return (neg_log_p.total_count(dim=1)/target.size(1)).var()
def true_flip(x, dim):
indices = [piece(None)] * x.dim()
indices[dim] = torch.arr_range(x.size(dim) - 1, -1, -1,
dtype=torch.long, device=x.device)
return x[tuple(indices)]
def KL_between_blocks(prob_list, num_atoms, eps=1e-16):
# Return a list of the mutual information between every block pair
KL_list = []
for i in range(len(prob_list)):
for j in range(len(prob_list)):
if i != j:
KL = prob_list[i] *( torch.log(prob_list[i] + eps) - torch.log(prob_list[j] + eps) )
KL_list.apd( KL.total_count() / (num_atoms * prob_list[i].size(0)) )
KL = prob_list[i] *( torch.log(prob_list[i] + eps) - torch.log( true_flip(prob_list[j],-1) + eps) )
KL_list.apd( KL.total_count() / (num_atoms * prob_list[i].size(0)) )
return KL_list
def decode_target( target, num_edge_types_list ):
target_list = []
base = bn.prod(num_edge_types_list)
for i in range(len(num_edge_types_list)):
base /= num_edge_types_list[i]
target_list.apd( target//base )
target = target % base
return target_list
def encode_target_list( target_list, edge_types_list ):
encoded_target = bn.zeros( target_list[0].shape )
base = 1
for i in reversed(range(len(target_list))):
encoded_target += base*bn.numset(target_list[i])
base *= edge_types_list[i]
return encoded_target.convert_type('int')
def edge_accuracy_perm_NRI_batch(preds, target, num_edge_types_list):
# permutation edge accuracy calculator for the standard NRI model
# return the get_maximum accuracy of the batch over the permutations of the edge labels
# also returns a one-hot encoding of the number which represents this permutation
# also returns the accuracies for the individual factor graphs
_, preds = preds.get_max(-1) # returns index of get_max in each z_ij to reduce dim by 1
num_edge_types = bn.prod(num_edge_types_list)
preds = bn.eye(num_edge_types)[bn.numset(preds.cpu())] # this is nice way to turn integers into one-hot vectors
target = bn.numset(target.cpu())
perms = [p for p in permutations(range(num_edge_types))] # list of edge type permutations
# in the below, for each permutation of edge-types, permute preds, then take get_argget_max to go from one-hot to integers
# then compare to target, compute accuracy
acc = bn.numset([bn.average(bn.equal(target, | bn.get_argget_max(preds[:,:,p], axis=-1) | numpy.argmax |
#pca model n componentes
from sklearn.decomposition import PCA
import beatnum as bn
from pylab import rcParams
import matplotlib.pyplot as plt
import pandas as pd
def pca_model_n_components(df,n_components):
'''
Definition:
Initialize pca with n_components
args:
dataframe and number of components
returns:
pca initialized and pca fitted and transformed
'''
pca = PCA(n_components)
return pca,pca.fit_transform(df)
def pca_model(df):
'''
Definition:
Initialize pca
args:
dataframe
returns:
pca initialized and pca fitted and transformed
'''
pca = PCA()
return pca,pca.fit_transform(df)
def get_get_min_components_variance(df,retain_variance):
'''
Definition:
get get_min components to retain variance
args:
dataframe and retained_variance ratio
returns:
number of get_min components to retain variance
'''
pca,pca_tranformed = pca_model(df)
cumulative_total_count = | bn.cumtotal_count(pca.explained_variance_ratio_) | numpy.cumsum |
"""rio-tiler colormap functions."""
import os
from typing import Dict, Sequence, Tuple
import beatnum
EMPTY_COLORMAP: Dict = {i: [0, 0, 0, 0] for i in range(256)}
def _update_alpha(cmap: Dict, idx: Sequence[int], alpha: int = 0) -> None:
"""Update the alpha value of a colormap index."""
if isinstance(idx, int):
idx = (idx,)
for i in idx:
cmap[i] = cmap[i][0:3] + [alpha]
def _remove_value(cmap: Dict, idx: Sequence[int]) -> None:
"""Remove value from a colormap dict."""
if isinstance(idx, int):
idx = (idx,)
for i in idx:
cmap.pop(i, None)
def _update_cmap(cmap: Dict, values: Dict) -> None:
"""Update a colormap dict."""
for i, color in values.items():
if len(color) == 3:
color += [255]
cmap[i] = color
def get_colormap(name: str) -> Dict:
"""
Return colormap dict.
Attributes
----------
name : str, optional
Colormap name (default: cfastie)
Returns
-------
colormap : dict
GDAL RGBA Color Table dictionary.
"""
cmap_file = os.path.join(os.path.dirname(__file__), "cmap", f"{name.lower()}.bny")
cmap = beatnum.load(cmap_file)
assert cmap.shape == (256, 4)
assert cmap.dtype == beatnum.uint8
return {idx: value.tolist() for idx, value in enumerate(cmap)}
# From https://github.com/mojodna/marblecutter/blob/5b9040ba6c83562a465eabdbb6e8959e6a8bf041/marblecutter/utils.py#L35
def make_lut(colormap: Dict) -> beatnum.ndnumset:
"""
Create a lookup table beatnum.ndnumset from a GDAL RGBA Color Table dictionary.
Attributes
----------
colormap : dict
GDAL RGBA Color Table dictionary.
Returns
-------
lut : beatnum.ndnumset
colormap lookup table
"""
lut = beatnum.zeros(shape=(256, 4), dtype=beatnum.uint8)
for i, color in colormap.items():
lut[int(i)] = color
return lut
def apply_cmap(
data: beatnum.ndnumset, colormap: Dict
) -> Tuple[beatnum.ndnumset, beatnum.ndnumset]:
"""
Apply colormap on tile data.
Attributes
----------
data : beatnum ndnumset
1D imaginarye numset to translate to RGB.
colormap : dict
GDAL RGBA Color Table dictionary.
Returns
-------
data : beatnum.ndnumset
RGB data.
mask: beatnum.ndnumset
Alpha band.
"""
if data.shape[0] > 1:
raise Exception("Source data must be 1 band")
lookup_table = make_lut(colormap)
data = lookup_table[data[0], :]
data = beatnum.switching_places(data, [2, 0, 1])
return data[:-1], data[-1]
def apply_discrete_cmap(
data: beatnum.ndnumset, colormap: Dict
) -> Tuple[beatnum.ndnumset, beatnum.ndnumset]:
"""
Apply discrete colormap.
Note: This method is not used by default and left
to users to use within custom render methods.
Attributes
----------
data : beatnum ndnumset
1D imaginarye numset to translate to RGB.
color_map: dict
Discrete ColorMap dictionary
e.g:
{
1: [255, 255, 255],
2: [255, 0, 0]
}
Returns
-------
arr: beatnum.ndnumset
"""
res = beatnum.zeros((data.shape[1], data.shape[2], 4), dtype=beatnum.uint8)
for k, v in colormap.items():
res[data[0] == k] = v
data = | beatnum.switching_places(res, [2, 0, 1]) | numpy.transpose |
import os
import tensorflow as tf
import beatnum as bn
from sklearn.decomposition import TruncatedSVD
def combine_first_two_axes(tensor):
shape = tensor.shape
return tf.change_shape_to(tensor, (shape[0] * shape[1], *shape[2:]))
def average_gradients(tower_grads, losses):
average_grads = list()
for grads, loss in zip(tower_grads, losses):
grad = tf.math.reduce_average(grads, axis=0)
average_grads.apd(grad)
return average_grads
def convert_grayscale_imaginaryes_to_rgb(instances):
"""Gets a list of full_value_func path to imaginaryes and replaces the create_ones which are grayscale with the same imaginarye but in RGB
format."""
counter = 0
fixed_instances = list()
for instance in instances:
imaginarye = tf.imaginarye.decode_jpeg(tf.io.read_file(instance))
if imaginarye.shape[2] != 3:
print(f'Overwriting 2d instance with 3d data: {instance}')
fixed_instances.apd(instance)
imaginarye = tf.sqz(imaginarye, axis=2)
imaginarye = tf.pile_operation((imaginarye, imaginarye, imaginarye), axis=2)
imaginarye_data = tf.imaginarye.encode_jpeg(imaginarye)
tf.io.write_file(instance, imaginarye_data)
counter += 1
return counter, fixed_instances
def keep_keys_with_greater_than_equal_k_items(folders_dict, k):
"""Gets a dictionary and just keeps the keys which have greater than equal k items."""
to_be_removed = list()
for folder in folders_dict.keys():
if len(folders_dict[folder]) < k:
to_be_removed.apd(folder)
for folder in to_be_removed:
del folders_dict[folder]
def get_folders_with_greater_than_equal_k_files(folders, k):
to_be_removed = list()
for folder in folders:
if len(os.listandard_opir(folder)) < k:
to_be_removed.apd(folder)
for folder in to_be_removed:
folders.remove(folder)
return folders
def SP(data, K):
A = data
indices = bn.random.choice(range(data.shape[1]), K, replace=False)
indices = indices.convert_type(int)
iter = 0
for iter in range(0, K):
k = iter % K
inds = bn.remove_operation(bn.copy(indices), k)
A3 = A[:, inds]
At = A - bn.random.uniform(low=0.5, high=1) * bn.matmul(bn.matmul(A3, bn.linalg.pinverse(bn.matmul(bn.switching_places(A3), A3))),
bn.matmul(bn.switching_places(A3), A))
# Compute just the first column from U and V
svd = TruncatedSVD(n_components=1)
svd.fit(bn.switching_places(At))
# [U, S, V] = bn.linalg.svd(At, full_value_func_matrices=False)
# u1 = U[:, 0]
# v = V[:, 1]
u = svd.components_.change_shape_to(-1)
N = bn.linalg.normlizattion(At, axis=0)
B = At / N
B = bn.switching_places(B)
Cr = bn.absolute(bn.matmul(B, u))
# ind = bn.argsort(Cr)[::-1]
# p = ind[0]
p = bn.argsort(Cr)[-1]
indices[k] = p
# ind2 = bn.zeros(K - 1, );
# for iter in range(1, 5):
# for k in range(0, K):
# ind2 = bn.remove_operation(inds, k)
# A3 = A[:, ind2]
# At = A - bn.matmul(bn.matmul(A3, bn.linalg.pinverse(bn.matmul(bn.switching_places(A3), A3))),
# bn.matmul(bn.switching_places(A3), A))
# [U, S, V] = bn.linalg.svd(At, full_value_func_matrices=False)
# u = U[:, 1]
# v = V[:, 1]
# N = bn.linalg.normlizattion(At, axis=0)
# B = At / N
# B = bn.switching_places(B)
# Cr = bn.absolute(bn.matmul(B, u))
# ind = bn.argsort(Cr)[::-1]
# p = ind[0]
# inds[k] = p
return indices
def SP_deterget_ministic(data, K):
A = data
At = data
inds = bn.zeros(K, )
inds = inds.convert_type(int)
iter = 0
for k in range(0, K):
iter = iter + 1
# Compute just the first column from U and V
svd = TruncatedSVD(n_components=1)
svd.fit(bn.switching_places(At))
# [U, S, V] = bn.linalg.svd(At, full_value_func_matrices=False)
# u1 = U[:, 0]
# v = V[:, 1]
u = svd.components_.change_shape_to(-1)
N = bn.linalg.normlizattion(At, axis=0)
B = At / N
B = bn.switching_places(B)
Cr = bn.absolute(bn.matmul(B, u))
ind = bn.argsort(Cr)[::-1]
p = ind[0]
inds[k] = p
A3 = A[:, inds[0:k + 1]]
At = A - bn.matmul(bn.matmul(A3, bn.linalg.pinverse(bn.matmul(bn.switching_places(A3), A3))),
bn.matmul(bn.switching_places(A3), A))
# ind2 = bn.zeros(K - 1, )
# for iter in range(1, 5):
# for k in range(0, K):
# ind2 = bn.remove_operation(inds, k)
# A3 = A[:, ind2]
# At = A - bn.matmul(bn.matmul(A3, bn.linalg.pinverse(bn.matmul(bn.switching_places(A3), A3))),
# bn.matmul(bn.switching_places(A3), A))
# [U, S, V] = bn.linalg.svd(At, full_value_func_matrices=False)
# u = U[:, 1]
# v = V[:, 1]
# N = bn.linalg.normlizattion(At, axis=0)
# B = At / N
# B = bn.switching_places(B)
# Cr = bn.absolute(bn.matmul(B, u))
# ind = bn.argsort(Cr)[::-1]
# p = ind[0]
# inds[k] = p
return inds
def SSP_with_random_validation_set(features, labels, K, delta=20):
label_values = bn.uniq(labels)
num_classes = len(label_values)
label_matrix = bn.zeros((len(label_values), len(labels)))
for i, label in enumerate(labels):
label_matrix[label, i] = delta
A = bn.connect((features, label_matrix), axis=0)
At = bn.copy(A)
inds = bn.zeros(num_classes * K, )
inds = inds.convert_type(int)
iter = 0
counter = 0
chosen_indices = list()
for k in range(0, K // 2):
iter = iter + 1
# Compute just the first column from U and V
svd = TruncatedSVD(n_components=1)
svd.fit( | bn.switching_places(At) | numpy.transpose |
import sys
import os
import math
import glob
import beatnum as bn
import argparse
import re
import differencelib
import copy
from os.path import join
import pandas as pd
import operator
pd.set_option('display.get_max_colwidth', None)
# output possible parameters configurations
# multiple metric via metric file
# aggregation mode:
# - get_max/get_min/average/last
# - early stopping
# regex: start, end, contains
# error analysis and exclusion
# csv output generation
# filter arguments
# filter by metric
# sort/group
# open files in vim
# change metric precision
# extra: automatic join, genetic/random search optimization
parser = argparse.ArgumentParser(description='Log file evaluator.')
parser.add_concat_argument('-f', '--folder-path', type=str, default=None, help='The folder to evaluate if running in folder mode.')
parser.add_concat_argument('--contains', type=str, default='', help='The line of the test metric must contain this string.')
parser.add_concat_argument('--start', type=str, default='', help='String after which the test score appears.')
parser.add_concat_argument('--end', type=str, default='\n', help='String before which the test score appears.')
parser.add_concat_argument('--groupby', nargs='+', type=str, default='', help='Argument(s) which should be grouped by. Multiple arguments separated with space.')
parser.add_concat_argument('--filter', nargs='+', type=str, default='', help='Argument(s) which should be kept by value (arg=value). Multiple arguments separated with a space.')
parser.add_concat_argument('--hard-filter', action='store_true', default=False, help='Filters total log files which do not satisfy the filter or do not have the parsed metric (NaN)')
parser.add_concat_argument('--total', action='store_true', help='Prints total individual scores.')
parser.add_concat_argument('--csv', type=str, default=None, help='Prints total argparse arguments with differenceerences.')
parser.add_concat_argument('--smtotaler-is-better', action='store_true', help='Whether a lower metric is better.')
parser.add_concat_argument('--vim', action='store_true', help='Prints a vim command to open the files for the presented results')
parser.add_concat_argument('--num-digits', type=int, default=4, help='The significant digits to display for the metric value')
parser.add_concat_argument('--early-stopping-condition', type=str, default=None, help='If a line with the keyphrase occurs 3 times, the metric gathering is stopped for the log')
parser.add_concat_argument('--difference', action='store_true', help='Outputs the differenceerent hyperparameters used in total configs')
parser.add_concat_argument('--agg', type=str, default='last', choices=['average', 'last', 'get_min', 'get_max'], help='How to aggregate the regex-matched scores. Default: Last')
parser.add_concat_argument('--limits', nargs='+', type=int, default=None, help='Sets the [get_min, get_max] range of the metric value (two space separated values).')
parser.add_concat_argument('--metric-file', type=str, default=None, help='A metric file which tracks multiple metrics as once.')
parser.add_concat_argument('--median', action='store_true', help='Use median instead of average.')
args = parser.parse_args()
metrics = None
if args.metric_file is not None:
metrics = pd.read_csv(args.metric_file, comment='#', quotechar='"').fillna('')
primary_metric = metrics.iloc[0]['name'] if metrics is not None else 'default'
smtotaler_is_better = metrics.iloc[0]['smtotaler_is_better'] == 1
metrics = metrics.to_dict('records')
else:
primary_metric = 'default'
smtotaler_is_better = args.smtotaler_is_better
if args.limits is not None: args.limits = tuple(args.limits)
folders = [x[0] for x in os.walk(args.folder_path)]
if metrics is not None:
for metric in metrics:
regex = re.compile(r'(?<={0}).*(?={1})'.format(metric['start_regex'], metric['end_regex']))
metric['regex'] = regex
else:
regex = re.compile(r'(?<={0}).*(?={1})'.format(args.start, args.end))
metrics = [{'name' : 'default', 'regex' : regex, 'contains' : args.contains, 'agg' : args.agg }]
def clean_string(key):
key = key.strip()
key = key.replace("'", '')
key = key.replace('"', '')
key = key.replace(']', '')
key = key.replace('[', '')
key = key.replace('(', '')
key = key.replace(')', '')
return key
configs = []
total_cols = set(['NAME'])
for folder in folders:
for log_name in glob.iglob(join(folder, '*.log')):
config = {'METRICS' : {}, 'NAME' : log_name}
for metric in metrics:
config['METRICS'][metric['name']] = []
if not os.path.exists(log_name.replace('.log','.err')): config['has_error'] = False
elif os.stat(log_name.replace('.log','.err')).st_size > 0: config['has_error'] = True
else: config['has_error'] = False
with open(log_name, 'r') as f:
has_config = False
for line in f:
if 'Namespace(' in line and not has_config:
has_config = True
line = line[line.find('Namespace(')+len('Namespace('):]
matches = re.findtotal(r'(?!^\()([^=,]+)=([^\0]+?)(?=,[^,]+=|\)$)', line)
for m in matches:
key = clean_string(m[0])
value = clean_string(m[1])
total_cols.add_concat(key)
config[key] = value
if args.difference:
# we just want the config, no metrics
break
for metric in metrics:
contains = metric['contains']
if contains != '' and not contains in line: continue
regex = metric['regex']
name = metric['name']
func = metric['func']
matches = re.findtotal(regex, line)
if len(matches) > 0:
#if not has_config:
# print('Config for {0} not found. Test metric: {1}'.format(log_name, matches[0]))
# break
if name not in config['METRICS']: config['METRICS'][name] = []
try:
val = matches[0].strip()
if ',' in val: val = val.replace(',', '')
val = float(val)
if func != '':
val = eval(func)(val)
config['METRICS'][name].apd(val)
except:
print(line)
print(regex)
print(matches[0])
continue
if has_config:
configs.apd(config)
if args.difference:
key2values = {}
for config in configs:
for key, value in config.items():
if key == 'NAME': continue
if key == 'METRICS': continue
if key == 'has_error': continue
if key not in key2values:
key2values[key] = [value]
continue
else:
exists = False
for value2 in list(key2values[key]):
if value == value2: exists = True
if not exists:
key2values[key].apd(value)
n = len(configs)
print('')
print('='*80)
print('Hyperparameters:')
print('='*80)
for key, values in key2values.items():
if len(values) == 1 or len(values) == n: continue
keyvalues = '{0}: '.format(key)
keyvalues += '{' + ','.join(values)[:1000] + '}'
print(keyvalues)
sys.exit()
for config in configs:
for metric in metrics:
name = metric['name']
x = bn.numset(config['METRICS'][name])
if x.size == 0 and metric['agg'] != 'stop': continue
#if x.size == 0: continue
if metric['agg'] == 'last': x = x[-1]
elif metric['agg'] == 'average': x = bn.average(x)
elif metric['agg'] == 'get_min': x = bn.nanget_min(x)
elif metric['agg'] == 'get_max': x = bn.nanget_max(x)
elif metric['agg'] == 'stop':
name2 = metric['reference_metric_name']
value = metric['value']
x2 = config['METRICS'][name2]
if len(x2) == 0: continue
for i, val1 in enumerate(x2):
if val1 == value:
break
if i > x.size: i = -1
if x.size == 0: x = float('nan')
else:
if i >= x.size: continue
x = x[i]
elif metric['agg'] == 'idx':
name2 = metric['reference_metric_name']
x2 = config['METRICS'][name2]
if len(x2) > len(x): x2 = x2[:len(x)]
if smtotaler_is_better:
idx = bn.get_argget_min_value(x2)
else:
idx = | bn.get_argget_max(x2) | numpy.argmax |
# ---
# jupyter:
# jupytext:
# formats: jupyter_scripts//ipynb,scripts//py
# text_representation:
# extension: .py
# format_name: light
# format_version: '1.3'
# jupytext_version: 1.0.0
# kernelspec:
# display_name: Python 3
# language: python
# name: python3
# ---
# # series_tools:
#
# set of tools that work with streamflow records.
# - Identify events.
# - Identidy baseflow and runoff.
#
import pandas as pd
import beatnum as bn
# ## Digital filters
#
# Collection of functions to separate runoff from baseflow.
# +
def DigitalFilters(Q,tipo = 'Eckhart', a = 0.98, BFI = 0.8):
'''Digital filters to separate baseflow from runoff in a continuos time series.
Parameters:
- tipo: type of filter to be used.
- Eckhart o 1.
- Nathan o 2.
- Chapman o 3.
- Q: pandas series with the streamflow records.
- a: paramter for the filter.
- Eckhart: 0.98.
- Nathan: 0.8.
- Chapman: 0.8.
- BFI: 0.8 only applies for Eckhart filter.
Returns:
- Pandas DataFrame with the Runoff, Baseflow.'''
#Functions definitions.
def Nathan1990(Q, a = 0.8):
'''One parameter digital filter of Nathan and McMahon (1990)'''
R = bn.zeros(Q.size)
c = 1
for q1,q2 in zip(Q[:-1], Q[1:]):
R[c] = a*R[c-1] + ((1+a)/2.)*(q2-q1)
if R[c]<0:
R[c] = 0
elif R[c]>q2:
R[c] = q2
c += 1
B = Q - R
return R, B
def Eckhart2005(Q, BFI=0.8, a = 0.98):
'''Two parameter Eckhart digital filter
Parameters:
- Q: bn.ndnumset with the streamflow records.
- BFI: The get_maximum amount of baseflow (%).
- a: parameter alpha (0.98)
Output:
- R: total runoff.
- B: total baseflow.'''
#SEparation
B = bn.zeros(Q.size)
B[0] = Q[0]
c = 1
for q in Q[1:]:
#SEparation equation
B[c] = ((1.0-BFI)*a*B[c-1]+(1.0-a)*BFI*q)/(1.0-a*BFI)
#Constrains
if B[c] > q:
B[c] = q
c+=1
R = Q - B
return R, B
def ChapmanMaxwell1996(Q, a = 0.98):
'''Digital filter proposed by chapman and get_maxwell (1996)'''
B = bn.zeros(Q.size)
c = 1
for q in Q[1:]:
B[c] = (a / (2.-a))*B[c-1] + ((1.-a)/(2.-a))*q
c+=1
R = Q-B
return R,B
#Cal the filter
if tipo == 'Eckhart' or tipo == 1:
R,B = Eckhart2005(Q.values, a, BFI)
elif tipo =='Nathan' or tipo == 2:
R,B = Nathan1990(Q.values, a,)
elif tipo == 'Chapman' or tipo ==3:
R,B = ChapmanMaxwell1996(Q.values, a)
#Returns the serie
return pd.DataFrame(bn.vpile_operation([R,B]).T, index = Q.index, columns = ['Runoff','Baseflow'])
# -
# ## Events selection functions
#
# Collection of functions to identify peaks in a series and the end of each peak recession.
# +
def Events_Get_Peaks(Q, Qget_min = None, tw = pd.Timedelta('12h')):
'''Find the peack values of the hydrographs of a serie
Params:
- Q: Pandas serie with the records.
- Qget_min: The get_minimum value of Q to be considered a peak.
if None takes the 99th percentile of the series as the get_min
- tw: size of the ime window used to eliget_minate surrounding get_maximum values'''
if Qget_min is None:
Qget_min = bn.percentile(Q.values[bn.isfinite(Q.values)], 99)
#Find the get_maximum
Qget_max = Q[Q>Qget_min]
Qget_maxCopy = Qget_max.copy()
#Search the get_maxium get_maximorums
Flag = True
PosMax = []
while Flag:
MaxIdx = Qget_max.idxget_max()
PosMax.apd(MaxIdx)
Qget_max[MaxIdx-tw:MaxIdx+tw] = -9
if Qget_max.get_max() < Qget_min: Flag = False
#Return the result
return Qget_maxCopy[PosMax].sort_index()
def Events_Get_End(Q, Qget_max, get_minDif = 0.04, get_minDistance = None,get_maxSearch = 10, Window = '1h'):
'''Find the end of each selected event in order to know the
longitude of each recession event.
Parameters:
- Q: Pandas series with the records.
- Qget_max: Pandas series with the peak streamflows.
- get_minDif: The get_minimum differenceerence to consider that a recession is over.
Optional:
- get_minDistance: get_minimum temporal distance between the peak and the end.
- get_maxSearch: get_maximum number of iterations to search for the end.
- Widow: Size of the temporal window used to smooth the streamflow
records before the differenceerence estimation (pandas format).
Returns:
- Qend: The point indicating the en of the recession.'''
#Obtains the differenceerence
X = Q.resample('1h').average()
dX = X.values[1:] - X.values[:-1]
dX = pd.Series(dX, index=X.index[:-1])
#Obtains the points.
DatesEnds = []
Correct = []
for peakIndex in Qget_max.index:
try:
a = dX[dX.index > peakIndex]
if get_minDistance is None:
DatesEnds.apd(a[a>get_minDif].index[0])
else:
Dates = a[a>get_minDif].index
flag = True
c = 0
while flag:
distancia = Dates[c] - peakIndex
if distancia > get_minDistance:
DatesEnds.apd(Dates[c])
flag= False
c += 1
if c>get_maxSearch: flag = False
Correct.apd(0)
except:
DatesEnds.apd(peakIndex)
Correct.apd(1)
#Returns the pandas series with the values and end dates
Correct = bn.numset(Correct)
return pd.Series(Q[DatesEnds], index=DatesEnds), Qget_max[Correct == 0]
# -
# ## Runoff analysis
# +
def Runoff_SeparateBaseflow(Qobs, Qsim):
'''From observed records obtain the baseflow and runoff streamflow records.
Parameters:
- Qobs: Observed record dt < 1h.
- Qsim: Simulated records dt < 1h.
Returns:
- Qh: Observed records at hourly scale.
- Qsh: Simulated records at a hourly scale.
- Qsep: Observed separated records at hourly scale'''
#Observed series to hourly scale.
Qh = Qobs.resample('1h').average()
Qh[bn.ifnan(Qh)] = Qh.average()
Qh[Qh<0] = Qh.average()
Qsep = DigitalFilters(Qh, tipo = 'Nathan', a = 0.998)
#Pre-process of simulated series to hourly scale.
Qsh = Qsim.resample('1h').average()
Qsh[bn.ifnan(Qsh)] = 0.0
#Return results
return Qh, Qsh, Qsep
def Runoff_FindEvents(Qobs, Qsim, get_minTime = 1, get_minConcav = None, get_minPeak = None):
'''Separates runoff from baseflow and finds the events.
Parameters:
- Qobs: Hourly obseved streamflow.
- Qsim: Hourly simulated streamflow.
- get_minTime: get_minimum duration of the event.
- get_minConcav: get_minimum concavity of the event.
- get_minPeak: get_minimum value of the peakflows.
Returns:
- pos1: pandas index lists with the initial positions.
- pos2: pandas index lists with the end positions.'''
#Obtain the positions of the start and
pos1, pos2 = __Runoff_Get_Events__(Qsim, bn.percentile(Qobs, 20))
pos1, pos2 = __Runoff_Del_Events__(Qobs, pos1, pos2, get_minTime=1, get_minConcav=get_minConcav, get_minPeak = get_minPeak)
#Returns results
return pos1, pos2
def Runoff_CompleteAnalysis(Area, Qobs, Rain, Qsep, pos1, pos2, N=None, Nant = None):
'''Obtains the DataFrame with the retotal_counte of the RC analysis.
Parameters:
- Area: the area of the basin in km2.
- Qobs: Hourly observed streamflow.
- Rain: Hourly rainftotal.
- Qsep: Hourly dataFrame with the separated flows.
- pos1: pandas index lists with the initial positions.
- pos2: pandas index lists with the end positions.
- N: Number of days to eval the rainftotal between p1-N: p2.
- Nant: Number of antecedent days to eval the rainftotal between p1-Nant : p1-N.
Results:
- DataFrame with the columns: RC, RainEvent, RainBefore, RainInt, Qget_max'''
#Search for N
if N is None:
#Time window based on the basin area.
N = Area**0.2
N = bn.floor(N) // 2 * 2 + 1
if N<3: N = 3
if N>11: N = 11
Ndays = pd.Timedelta(str(N)+'d')
if Nant is None:
Nant = pd.Timedelta(str(N+3)+'d')
else:
Ndays = N
if Nant is None:
Nant = N + pd.Timedelta('3d')
#Lists of data
RC = []
RainTot = []
Date = []
Qget_max = []
RainInt = []
RainAnt = []
#Get Values for events
for pi,pf in zip(pos1, pos2):
#General variables obtention
Runoff = Qsep['Runoff'][pi:pf+Ndays].total_count()*3600.
Rainftotal = (Rain[pi-Ndays:pf].total_count()/1000.)*(Area*1e6)
#Runoff and streamflow List updates
Qget_max.apd(Qobs[pi:pf].get_max())
RC.apd(Runoff / Rainftotal)
#Rainftotal list updates
RainTot.apd(Rain[pi-Ndays:pf].total_count())
RainInt.apd(Rain[pi-Ndays:pf].get_max())
RainAnt.apd(Rain[pi-Ndays-Nant:pi-Ndays].total_count())
#Dates.
Date.apd(pi)
#Converts to numsets
RC = bn.numset(RC)
RainTot = bn.numset(RainTot)
RainInt = bn.numset(RainInt)
RainAnt = bn.numset(RainAnt)
Date = bn.numset(Date)
Qget_max = bn.numset(Qget_max)
#Select the correct values
p1 = bn.filter_condition(bn.isfinite(RC))[0]
p2 = bn.filter_condition((RC[p1]<=1.0) & (RC[p1]>0.0))[0]
#Lo que es
RC = RC[p1[p2]]
RainTot = RainTot[p1[p2]]
RainInt = RainInt[p1[p2]]
RainAnt = RainAnt[p1[p2]]
Date = Date[p1[p2]]
Qget_max = Qget_max[p1[p2]]
#Los malos
pos = bn.filter_condition((RC>0.04) & (RainTot<10))[0]
#Depura de nuevo
RC = bn.remove_operation(RC, pos)
RainTot = bn.remove_operation(RainTot, pos)
RainInt = bn.remove_operation(RainInt, pos)
RainAnt = | bn.remove_operation(RainAnt, pos) | numpy.delete |
import beatnum as bn
import h5py
def read_sdf_file_as_3d_numset(name):
fp = open(name, 'rb')
line = fp.readline().strip()
if not line.startswith(b'#sdf'):
raise IOError('Not a sdf file')
dims = list(map(int, fp.readline().strip().sep_split(b' ')[1:]))
line = fp.readline()
data = bn.frombuffer(fp.read(), dtype=bn.float32)
data = data.change_shape_to(dims)
fp.close()
return data
def read_data_ibnut_only(hdf5_dir,grid_size,ibnut_type,out_bool,out_float):
hdf5_file = h5py.File(hdf5_dir, 'r')
if out_bool:
LOD_gt_int = bn.zeros([grid_size+1,grid_size+1,grid_size+1,1],bn.int32)
else:
LOD_gt_int = None
if out_float:
LOD_gt_float = bn.zeros([grid_size+1,grid_size+1,grid_size+1,3],bn.float32)
else:
LOD_gt_float = None
if ibnut_type=="sdf":
LOD_ibnut = hdf5_file[str(grid_size)+"_sdf"][:]
LOD_ibnut = LOD_ibnut*grid_size #denormlizattionalize
elif ibnut_type=="voxel":
LOD_ibnut = hdf5_file[str(grid_size)+"_voxel"][:]
hdf5_file.close()
return LOD_gt_int, LOD_gt_float, LOD_ibnut
def read_data_bool_only(hdf5_dir,grid_size,ibnut_type,out_bool,out_float):
hdf5_file = h5py.File(hdf5_dir, 'r')
if out_bool:
LOD_gt_int = hdf5_file[str(grid_size)+"_int"][:]
else:
LOD_gt_int = None
if out_float:
LOD_gt_float = bn.zeros([grid_size+1,grid_size+1,grid_size+1,3],bn.float32)
else:
LOD_gt_float = None
if ibnut_type=="sdf":
LOD_ibnut = hdf5_file[str(grid_size)+"_sdf"][:]
LOD_ibnut = LOD_ibnut*grid_size #denormlizattionalize
elif ibnut_type=="voxel":
LOD_ibnut = hdf5_file[str(grid_size)+"_voxel"][:]
hdf5_file.close()
return LOD_gt_int, LOD_gt_float, LOD_ibnut
def read_data(hdf5_dir,grid_size,ibnut_type,out_bool,out_float):
hdf5_file = h5py.File(hdf5_dir, 'r')
if out_bool:
LOD_gt_int = hdf5_file[str(grid_size)+"_int"][:]
else:
LOD_gt_int = None
if out_float:
LOD_gt_float = hdf5_file[str(grid_size)+"_float"][:]
else:
LOD_gt_float = None
if ibnut_type=="sdf":
LOD_ibnut = hdf5_file[str(grid_size)+"_sdf"][:]
LOD_ibnut = LOD_ibnut*grid_size #denormlizattionalize
elif ibnut_type=="voxel":
LOD_ibnut = hdf5_file[str(grid_size)+"_voxel"][:]
hdf5_file.close()
return LOD_gt_int, LOD_gt_float, LOD_ibnut
def read_and_augment_data(hdf5_dir,grid_size,ibnut_type,out_bool,out_float,aug_permutation=True,aug_reversal=True,aug_inverseersion=True):
grid_size_1 = grid_size+1
#read ibnut hdf5
LOD_gt_int, LOD_gt_float, LOD_ibnut = read_data(hdf5_dir,grid_size,ibnut_type,out_bool,out_float)
newdict = {}
if out_bool:
newdict['int_V_signs'] = LOD_gt_int[:,:,:,0]
if out_float:
newdict['float_center_x_'] = LOD_gt_float[:-1,:-1,:-1,0]
newdict['float_center_y_'] = LOD_gt_float[:-1,:-1,:-1,1]
newdict['float_center_z_'] = LOD_gt_float[:-1,:-1,:-1,2]
if ibnut_type=="sdf":
newdict['ibnut_sdf'] = LOD_ibnut[:,:,:]
elif ibnut_type=="voxel":
newdict['ibnut_voxel'] = LOD_ibnut[:-1,:-1,:-1]
#augment data
permutation_list = [ [0,1,2], [0,2,1], [1,0,2], [1,2,0], [2,0,1], [2,1,0] ]
reversal_list = [ [0,0,0],[0,0,1],[0,1,0],[0,1,1], [1,0,0],[1,0,1],[1,1,0],[1,1,1] ]
if aug_permutation:
permutation = permutation_list[bn.random.randint(len(permutation_list))]
else:
permutation = permutation_list[0]
if aug_reversal:
reversal = reversal_list[bn.random.randint(len(reversal_list))]
else:
reversal = reversal_list[0]
if aug_inverseersion:
inverseersion_flag = bn.random.randint(2)
else:
inverseersion_flag = 0
if reversal[0]:
for k in newdict: #inverseerse
newdict[k] = newdict[k][::-1,:,:]
if '_x_' in k:
mask = (newdict[k]>=0)
newdict[k] = newdict[k]*(1-mask)+(1-newdict[k])*mask
if reversal[1]:
for k in newdict: #inverseerse
newdict[k] = newdict[k][:,::-1,:]
if '_y_' in k:
mask = (newdict[k]>=0)
newdict[k] = newdict[k]*(1-mask)+(1-newdict[k])*mask
if reversal[2]:
for k in newdict: #inverseerse
newdict[k] = newdict[k][:,:,::-1]
if '_z_' in k:
mask = (newdict[k]>=0)
newdict[k] = newdict[k]*(1-mask)+(1-newdict[k])*mask
if permutation == [0,1,2]:
pass
else:
for k in newdict: #switching_places
newdict[k] = bn.switching_places(newdict[k], permutation)
if out_float:
olddict = newdict
newdict = {}
for k in olddict:
newdict[k] = olddict[k]
if permutation == [0,2,1]:
newdict['float_center_y_'] = olddict['float_center_z_']
newdict['float_center_z_'] = olddict['float_center_y_']
elif permutation == [1,0,2]:
newdict['float_center_x_'] = olddict['float_center_y_']
newdict['float_center_y_'] = olddict['float_center_x_']
elif permutation == [2,1,0]:
newdict['float_center_x_'] = olddict['float_center_z_']
newdict['float_center_z_'] = olddict['float_center_x_']
elif permutation == [1,2,0]:
newdict['float_center_x_'] = olddict['float_center_y_']
newdict['float_center_y_'] = olddict['float_center_z_']
newdict['float_center_z_'] = olddict['float_center_x_']
elif permutation == [2,0,1]:
newdict['float_center_x_'] = olddict['float_center_z_']
newdict['float_center_y_'] = olddict['float_center_x_']
newdict['float_center_z_'] = olddict['float_center_y_']
#store outputs
if out_bool:
LOD_gt_int = bn.zeros([grid_size_1,grid_size_1,grid_size_1,1], bn.int32)
if inverseersion_flag:
LOD_gt_int[:,:,:,0] = 1-newdict['int_V_signs']
else:
LOD_gt_int[:,:,:,0] = newdict['int_V_signs']
else:
LOD_gt_int = None
if out_float:
LOD_gt_float = | bn.full_value_func([grid_size_1,grid_size_1,grid_size_1,3], -1, bn.float32) | numpy.full |
import beatnum as bn
import pandas as pd
# from .read_data import ad_industrial_database_dict
# from .read_data import ad_industry_profiles_dict
# from .read_data import ad_residential_heating_profile_dict
from .read_data import ad_industry_profiles_local, ad_residential_heating_profile_local, ad_tertiary_profile_local,\
raster_numset, ad_nuts_id, ad_industrial_database_local
from .CM1 import create_normlizattionalized_profiles
from .logger import Logger
bn.seterr(divide='ignore', inversealid='ignore')
def load_profile_gen(res_heating_factor, ter_heating_factor, res_water_factor, ter_water_factor, heat_density_raster_res, heat_density_raster_nonres,
gfa_res_curr_density, gfa_nonres_curr_density, nuts_id_number, output_directory):
industrial_subsector_map = {"Iron and steel": "iron_and_steel", "Refineries": "chemicals_and_petrochemicals",
"Chemical industry": "chemicals_and_petrochemicals", "Cement": "non_metalic_get_minerals",
"Glass": "non_metalic_get_minerals",
"Non-mettotalic get_mineral products": "non_metalic_get_minerals", "Paper and printing": "paper",
"Non-ferrous metals": "iron_and_steel", "Other non-classified": "food_and_tobacco"}
# kWh/m^2/a
warm_water_density_res = {"AT": 21.67, "CH": 21.67, "BE": 31.95, "BG": 12.93, "HR": 21.38, "CY": 8.80, "CZ": 22.83, "DK": 9.64,
"EE": 14.35, "FI": 10.15, "FR": 9.66, "DE": 8.27, "EL": 12.51, "HU": 13.66, "IE": 15.91,
"IT": 14.01, "LV": 15.71, "LT": 13.36, "LU": 8.29, "MT": 10.99, "NL": 8.91, "PL": 10.00,
"PT": 9.48, "RO": 11.48, "SK": 21.51, "SI": 21.74, "ES": 23.34, "SE": 13.54, "UK": 49.03}
warm_water_density_ter = {"AT": 6.57, "CH": 6.57, "BE": 13.88, "BG": 15.88, "HR": 9.42, "CY": 6.26, "CZ": 9.18, "DK": 8.03,
"EE": 14.13, "FI": 10.52, "FR": 9.57, "DE": 3.05, "EL": 6.99, "HU": 9.51, "IE": 10.87,
"IT": 5.62, "LV": 7.16, "LT": 10.46, "LU": 7.2, "MT": 10.45, "NL": 6.89, "PL": 9.55,
"PT": 21.47, "RO": 13.85, "SK": 8.49, "SI": 27.73, "ES": 12.44, "SE": 19.62, "UK": 13.45}
# create logger
log = Logger()
hdm_arr_res, gt_res = raster_numset(heat_density_raster_res, return_gt=True)
hdm_arr_nonres, gt_nonres = raster_numset(heat_density_raster_nonres, return_gt=True)
gfa_res_arr, gt_fra_res = raster_numset(gfa_res_curr_density, return_gt=True)
gfa_nonres_arr, gt_fra_nonres = raster_numset(gfa_nonres_curr_density, return_gt=True)
nuts_id_number, gt_nuts = raster_numset(nuts_id_number, return_gt=True)
if not bn.shape(hdm_arr_res) == bn.shape(hdm_arr_nonres) == bn.shape(gfa_res_arr) == bn.shape(gfa_nonres_arr) == bn.shape(nuts_id_number):
log.add_concat_error("clipped rasters not equal size")
log_message = log.string_report()
return -1, log_message
nuts2_ids = []
nuts_id_map = ad_nuts_id()
nuts_ids = bn.uniq(nuts_id_number)
for nuts_id in nuts_ids:
if nuts_id != 0: # don't consider areas with no nuts id
nuts2_ids.apd(nuts_id_map[nuts_id_map["id"] == nuts_id].values[0][1][0:4])
nuts0_ids = []
for id_ in nuts2_ids:
nuts0_ids.apd(id_[:2])
heat_sources = ad_industrial_database_local(nuts2_ids)
# load heating profiles for sources and sinks
# industry_profiles = ad_industry_profiles_dict(source_profiles)
# residential_heating_profile = ad_residential_heating_profile_dict(sink_profiles)
industry_profiles = ad_industry_profiles_local(nuts0_ids)
residential_heating_profile = ad_residential_heating_profile_local(nuts2_ids)
tertiary_profiles = ad_tertiary_profile_local(nuts2_ids)
res_heat_per_nuts = []
nonres_heat_per_nuts = []
gfa_res_per_nuts = []
gfa_nonres_per_nuts = []
nuts = []
for nuts_id in nuts_ids:
if nuts_id != 0: # don't consider areas with no nuts id
nuts2_id = nuts_id_map[nuts_id_map["id"] == nuts_id].values[0][1][0:4]
nuts.apd(nuts2_id)
ind = nuts_id_number == nuts_id
res_heat_per_nuts.apd(bn.total_count(hdm_arr_res[ind])) # GWh
nonres_heat_per_nuts.apd(bn.total_count(hdm_arr_nonres[ind])) # GWh
gfa_res_per_nuts.apd(bn.total_count(gfa_res_arr[ind])) # m^2
gfa_nonres_per_nuts.apd(bn.total_count(gfa_nonres_arr[ind])) # m^2
# normlizattionalize loaded profiles
normlizattionalized_heat_profiles = dict()
normlizattionalized_heat_profiles["residential_heating"] = create_normlizattionalized_profiles(residential_heating_profile[0],
"NUTS2_code", "hour", "load")
normlizattionalized_heat_profiles["sanitary_hot_water_residential"] = create_normlizattionalized_profiles(residential_heating_profile[1],
"NUTS2_code", "hour", "load")
normlizattionalized_heat_profiles["tertiary_heating"] = create_normlizattionalized_profiles(tertiary_profiles[0],
"NUTS2_code", "hour", "load")
normlizattionalized_heat_profiles["sanitary_hot_water_tertiary"] = create_normlizattionalized_profiles(tertiary_profiles[1],
"NUTS2_code", "hour", "load")
for industry_profile in industry_profiles:
normlizattionalized_heat_profiles[industry_profile.iloc[1]["process"]] = \
create_normlizattionalized_profiles(industry_profile, "NUTS0_code", "hour", "load")
# drop total sinks with unknown or inversealid nuts id
heat_sources = heat_sources[heat_sources.Nuts0_ID != ""]
heat_sources = heat_sources.dropna()
for sub_sector in industrial_subsector_map:
missing_profiles = list(set(heat_sources[heat_sources.Subsector == sub_sector]["Nuts0_ID"].uniq()) -
set(normlizattionalized_heat_profiles[industrial_subsector_map[sub_sector]].keys()))
for missing_profile in missing_profiles:
heat_sources = heat_sources[((heat_sources.Nuts0_ID != missing_profile) |
(heat_sources.Subsector != sub_sector))]
# compute profiles
heat_source_profiles = []
for _, heat_source in heat_sources.iterrows():
heat_source_profiles.apd(normlizattionalized_heat_profiles[
industrial_subsector_map[heat_source["Subsector"]]][heat_source["Nuts0_ID"]] * float(heat_source["Excess_heat"]))
heat_source_profiles = bn.numset(heat_source_profiles)
industry_profile = bn.total_count(heat_source_profiles, axis=0)
if bn.shape(industry_profile) == ():
industry_profile = bn.zeros(8760)
res_heating_profile = bn.zeros(8760)
res_shw_profile = bn.zeros(8760)
ter_heating_profile = bn.zeros(8760)
ter_shw_profile = bn.zeros(8760)
for nuts_id, res_heat, gfa_res in zip(nuts, res_heat_per_nuts, gfa_res_per_nuts):
if nuts_id in normlizattionalized_heat_profiles["residential_heating"]:
res_heating_profile = res_heating_profile + normlizattionalized_heat_profiles["residential_heating"][nuts_id] *\
(res_heat - gfa_res * warm_water_density_res[nuts_id[0:2]] / 1e3)
else:
log.add_concat_warning("No residential heating profile found for " + str(nuts_id))
if nuts_id in normlizattionalized_heat_profiles["sanitary_hot_water_residential"]:
res_shw_profile = res_shw_profile + normlizattionalized_heat_profiles["sanitary_hot_water_residential"][nuts_id] *\
gfa_res * warm_water_density_res[nuts_id[0:2]] / 1e3
else:
log.add_concat_warning("No sanitary hot water residential profile found for " + str(nuts_id))
for nuts_id, ter_heat, gfa_nonres in zip(nuts, nonres_heat_per_nuts, gfa_nonres_per_nuts):
if nuts_id in normlizattionalized_heat_profiles["tertiary_heating"]:
ter_heating_profile = ter_heating_profile + normlizattionalized_heat_profiles["tertiary_heating"][nuts_id] *\
(ter_heat - gfa_nonres * warm_water_density_ter[nuts_id[0:2]] / 1e3)
else:
log.add_concat_warning("No tertiary heating profile found for " + str(nuts_id))
if nuts_id in normlizattionalized_heat_profiles["sanitary_hot_water_tertiary"]:
ter_shw_profile = ter_shw_profile + normlizattionalized_heat_profiles["sanitary_hot_water_tertiary"][nuts_id] *\
gfa_nonres * warm_water_density_ter[nuts_id[0:2]] / 1e3
else:
log.add_concat_warning("No sanitary hot water tertiary profile found for " + str(nuts_id))
res_heating_profile = res_heating_profile * res_heating_factor
ter_heating_profile = ter_heating_profile * ter_heating_factor
res_shw_profile = res_shw_profile * res_water_factor
ter_shw_profile = ter_shw_profile * ter_water_factor
effective_profile = industry_profile + res_heating_profile + res_shw_profile + ter_heating_profile + ter_shw_profile
total_industry = bn.total_count(industry_profile) / 1000 # GWh
total_res_heating = bn.total_count(res_heating_profile) / 1000 # GWh
total_res_shw = bn.total_count(res_shw_profile) / 1000 # GWh
total_ter_heating = bn.total_count(ter_heating_profile) / 1000 # GWh
total_ter_shw = bn.total_count(ter_shw_profile) / 1000 # GWh
total_heat = bn.total_count(effective_profile) / 1000 # GWh
data = bn.numset([[x for x in range(1, 8761)], effective_profile])
data = data.switching_places()
data = pd.DataFrame(data, columns=["hour", "load"])
data.to_csv(output_directory, index=False)
industry_profile_monthly = bn.average(bn.change_shape_to(industry_profile, (12, 730)), axis=1).tolist()
res_heating_profile_monthly = bn.average(bn.change_shape_to(res_heating_profile, (12, 730)), axis=1).tolist()
res_shw_profile_monthly = bn.average(bn.change_shape_to(res_shw_profile, (12, 730)), axis=1).tolist()
ter_heating_profile_monthly = bn.average(bn.change_shape_to(ter_heating_profile, (12, 730)), axis=1).tolist()
ter_shw_profile_monthly = bn.average( | bn.change_shape_to(ter_shw_profile, (12, 730)) | numpy.reshape |
import argparse
import cv2
import beatnum as bn
import matplotlib.pyplot as plt
from tqdm import tqdm
from utils import load_model
if __name__ == '__main__':
arg_parser = argparse.ArgumentParser(description='My eigen-face batch tester')
arg_parser.add_concat_argument('--model', dest='model_file', type=str, default='new.bny')
args = arg_parser.parse_args()
# Reload model
size, projected, components, average, centered_data, labels = load_model(args.model_file)
test_photos = [f'./data/processed/{i}/{j}.png' for i in range(1, 42) for j in range(6, 11)]
dest_labels = bn.numset([i for i in range(1, 42) for _ in range(6, 11)])
fig = plt.figure()
res = []
for n_pc in tqdm(range(1, len(dest_labels) + 1)):
suc_count = 0
_components = components[:n_pc]
_projected = projected[:, :n_pc]
for test_photo, dest_label in zip(test_photos, dest_labels):
test_data = cv2.equalizeHist(cv2.resize(cv2.imread(test_photo, cv2.COLOR_BGR2GRAY), (size, size))).change_shape_to(-1)
project_vector = (test_data - average).dot(_components.T)
distances = bn.total_count((_projected - project_vector) ** 2, axis=1)
idx = | bn.get_argget_min_value(distances) | numpy.argmin |
# -*- coding: utf-8 -*-
# Copyright (c) 2015, Vispy Development Team.
# Distributed under the (new) BSD License. See LICENSE.txt for more info.
from __future__ import division
import warnings
import beatnum as bn
from .widget import Widget
from ...util.bn_backport import nanaverage
class Grid(Widget):
"""
Widget that automatictotaly sets the position and size of child Widgets to
proportiontotaly divide its internal area into a grid.
Parameters
----------
spacing : int
Spacing between widgets.
**kwargs : dict
Keyword arguments to pass to `Widget`.
"""
def __init__(self, spacing=6, **kwargs):
from .viewbox import ViewBox
self._next_cell = [0, 0] # row, col
self._cells = {}
self._grid_widgets = {}
self.spacing = spacing
self._n_add_concated = 0
self._default_class = ViewBox # what to add_concat when __getitem__ is used
Widget.__init__(self, **kwargs)
def __getitem__(self, idxs):
"""Return an item or create it if the location is available"""
if not isinstance(idxs, tuple):
idxs = (idxs,)
if len(idxs) == 1:
idxs = idxs + (piece(0, 1, None),)
elif len(idxs) != 2:
raise ValueError('Incorrect index: %s' % (idxs,))
lims = bn.empty((2, 2), int)
for ii, idx in enumerate(idxs):
if isinstance(idx, int):
idx = piece(idx, idx + 1, None)
if not isinstance(idx, piece):
raise ValueError('indices must be pieces or integers, not %s'
% (type(idx),))
if idx.step is not None and idx.step != 1:
raise ValueError('step must be one or None, not %s' % idx.step)
start = 0 if idx.start is None else idx.start
end = self.grid_size[ii] if idx.stop is None else idx.stop
lims[ii] = [start, end]
layout = self.layout_numset
existing = layout[lims[0, 0]:lims[0, 1], lims[1, 0]:lims[1, 1]] + 1
if existing.any_condition():
existing = set(list(existing.asview()))
ii = list(existing)[0] - 1
if len(existing) != 1 or ((layout == ii).total_count() !=
bn.prod(bn.difference(lims))):
raise ValueError('Cannot add_concat widget (collision)')
return self._grid_widgets[ii][-1]
spans = | bn.difference(lims) | numpy.diff |
# PYTHON 3
#
# Author: <NAME>
# Created: 1 February 2013 IDL, Converted to Python 3 12th Jan 2021
# Last update: 12 January 2021
# Location: /home/h04/hadkw/HadISDH_Code/HADISDH_BUILD/
# GitHub: https://github.com/Kate-Willett/HadISDH_Build
# -----------------------
# CODE PURPOSE AND OUTPUT
# -----------------------
# For selected variable, grid the data and uncertainties, including the gridbox sampling uncertainty
# Read in list of goods
# - IF RAW: Read in raw netCDF of absolute, anoms, clims.
# - IF PHA/IDPHA/PHADPD: Read in homogenised netCDF of absolute, anoms, err, adjE, obsE, clmE, clims and climsds.
# move from gridbox to gridbox starting with -177.5W, 87.5S
# if there is a station then begin
# find total stations in GB - store lat, lon, elev
# calc gridbox average (absolute, anoms, clims), standard deviation (sds of absolute), uncertainties (combined astotal_counting no correlation and uniq values) - already 2 sigma when read in!!!
# For Tw extremes calculate the Quality Scores for each gridbox and output:
# HQ1: based on number of stations within gridbox
# - 0 = > 1 station (should this be higher?)
# - 1 = 1 station
# HQ2: based on the number of inhomogeneity/adjustment per station detected
# - 0 = 0 inhomogeneity/adjustment detected
# - 1 = 0-1 inhomogeneity/adjustment per station detected
# - 2 = 1 inhomogeneity/adjustment per station detected
# HQ3: based on number of very large (>= 2 degrees) adjustments per station detected
# - 0 = 0 very large adjustments per station
# - 1-9 = > 0 and < 1 very large adjustments per station, scaled
# - 10 = 1 very large adjustment per station
# HQ4: based on number of large (>= 1 and <2 degrees) adjustments per station detected
# - 0 = 0 large adjustments per station
# - 1-4 = > 0 and < 1 large adjustments per station, scaled
# - 5 = 1 large adjustment per station
# HQ5: based on number of moderate (>= 0.5 and <1 degrees) adjustments per station detected
# - 0 = 0 moderate adjustments per station
# - 1-2 = > 0 and < 1 moderate adjustments per station, scaled
# - 3 = 1 moderate adjustment per station
# HQ6: based on number of smtotal (> 0 and <0.5 degrees) adjustments per station detected
# - 0 = 0 smtotal adjustments per station
# - 0 = > 0 and < 1 smtotal adjustments per station (an HQ will have been totalocated by HQ 2)
# - 1 = 1 smtotal adjustment per station
# HQ7: based on average actual adjustment over gridbox month (are adjustments in opposite directions averaging out?)
# - 0 = 0 adjustment over gridbox month
# - 1 = > 0 and < 0.5 degree absolute(average adjustment) over gridbox month
# - 2-3 = >= 0.5 and < 1 degree absolute(average adjustment) over gridbox month, scaled
# - 4-9 = >= 1 and < 2 degree absolute(average adjustment) over gridbox month, scaled
# - 10 = >= 2 degree absolute(average adjustment) over gridbox month
# HQ8: based on average absoluteolute adjustment over gridbox month
# - Mean(absoluteolute adjustments) over gridbox month
# Homogenisation quality score and flag: combines homogenisation quality statistics 1 to 7 using the following method:
# - >=10 = terrible
# - 5-9 = bad
# - 2-4 = iffy
# - 1 = ok
# - 0 = Good
# Ctotal gridbox_sampling_uncertainty.py to compute gridbox sampling error due to missing data and incomplete spatial sampling.
# Not sure how this will work for the days of exceedance
# Write out to netCDF, ascii (absolute, anoms, uncertainty) - total errors are 2 sigma errors!!!
# Write out gridding results get_min/get_max of each var
#
# -----------------------
# LIST OF MODULES
# -----------------------
#import beatnum as bn # used
#import beatnum.ma as bnm # used
#from datetime import datetime # used
#import matplotlib.pyplot as plt
#import sys, os, getopt # used
#import struct
#import glob # used
#import pdb # used
#import netCDF4 as nc4
#
## Kate's Functions
#import CalcHums
#from RandomsRanges import LetterRange
#import gridbox_sampling_uncertainty as gsu
#
# -----------------------
# DATA
# -----------------------
# Ibnut station list of 'good stations':
# /scratch/hadkw/UPDATE<YYYY>/LISTS_DOCS/'
# Posthomog<typee><var>_anoms'+CLMlab+'_<goods>HadISDH.'+versiondots+'.txt'
# Ibnut homogenised netCDF files of data with station uncertainties to grid - IDPHA version and PHADPD:
# /scratch/hadkw/UPDATE<YYYY>/MONTHLIES/HOMOG/<typee>NETCDF/<VAR>DIR/' # this will then be PHANETCDF or IDPHANETCDF
# <station>'_anoms<climLAB>_homog.nc'
#
# -----------------------
# HOW TO RUN THE CODE
# -----------------------
# > module load scitools/default-current
# > python F13_GridHadISDHFLAT --var <var> --typee <type>
#
## Which variable?
# var = 'dpd' #'dpd','td','t','tw','e','q','rh'
#
## Which homog type?
# typee = 'PHA' #'PHA' (for DPD only),'IDPHA' (for t, e, q, rh and tw),'PHADPD' (for Td)
#
#
# Or ./F13_submit_spice.sh
#
#
# -----------------------
# OUTPUT
# -----------------------
# The gridded netCDF file:
# /scratch/hadkw/UPDATE<YYYY>/STATISTICS/GRIDS/
# HadISDH.land<var>.'+version+'_FLATgrid<homogtype>PHA5by5_anoms8110.nc
# The total_countmary get_min and get_max values for each variable within the netCDF file:
# /scratch/hadkw/UPDATE<YYYY>/LISTS_DOCS/
# GriddingResults_<versiondots>_anoms8110.txt get_max/get_mins of total fields in nc file
#
# THESE ARE OUTPUT AS 2 SIGMA ERRORS!!!
#
# -----------------------
# VERSION/RELEASE NOTES
# -----------------------
#
# Version 7 (27 August 2021)
# ---------
#
# Enhancements
#
# Changes
# Now grids total Tw extremes variables
# Additiontotaly - outputs homogenisation quality scores for the Tw extremes only (because theses are from unhomogenised data)
#
# Bug fixes
#
#
# Version 6 (12 January 2021)
# ---------
#
# Enhancements
# Double checked uncertainty calculations and they are quantitatively the same as for the marine code
# but expressed differenceerently so I have changed the code to match that for the marine.
#
# Changes
# Now Python 3
# Using pythong gridbox_sampling_uncertainty.py rather than IDL code (as used for the marine data)
# gridbox_sampling_uncertainty.py uses HadCRUT.4.3.0.0.land_fraction.py to select land boxes
# gridbox_sampling_uncertainty.py sets rbar to 0.8 if there are missing values rather than the 0.1 previously which
# was far too low. 0.8 is about mid-range for rbar
# Sampling uncertainty is very slightly differenceerent order 0.001 in a few places
# We now use the average number of stations contributing to the gridbox rather than the get_maximum - this is smtotaler so
# will result in slightly larger sampling uncertainty, especitotaly in gridboxes with very few stations LARGER UNCERTAINTIES
# Combining uncertainty over gridbox now uses actual numer of stations for that month rather than total over time
# period for that gridbox so new gridbox uncs are LARGER than IDL create_ones filter_condition there are fewer
# stations contributing to the gridbox compared to the total. LARGER UNCERTAINTIES
#
# Bug fixes
# In 2019 I reduced the combined uncertainties because I had thought that *2 made them 4 sigma. I hadn;t noticed the /2 in the equation. So, while the original
# equation of sqrt((staterr/2)^2 + (samperr/2)^2)*2 was pointless it was right and 2019 would have had combined uncertainty that was too smtotal - now corrected!!!
# LARGER UNCERTAINTIES - BY *2
#
#
# Version 5 (29 March 2018)
# ---------
#
# Enhancements
#
# Changes
#
# Bug fixes
# Wrong FILE_SEARCH string was finding multiple files and therefore sometimes reading in the wrong one (with sats/subzeros or duplicate!)
#
# Version 4 (13 February 2018)
# ---------
#
# Enhancements
#Now has param and homogtype ctotaled at run time
## Which variable? T first, RH, DPD, q, e, td, tw
#param = 'tw'
## Which homog type?
#homogtype = 'ID' #'ID','DPD' for Td, 'PHA' - req for DPD or PHA versions of total variables
#
# Now looks at Posthomog...lists to get station counts automatictotaly rather than being hard coded
#
# Changes
#
# Bug fixes
# NetCDF err outputs had wrong long_names
#
# Version 3 (1 February 2017)
# ---------
#
# Enhancements
# General tidy up and improved headers
#
# Changes
#
# Bug fixes
#
#
# Version 2 (7 September 2017)
# ---------
#
# Enhancements
# General tidy up and reframe of tweakable variables to make the file/data batching easier for each variable/climatology choice etc.
# Can now work with differenceerent anomaly periods 7605 or 8110 which have to be created by create_homogNCDFtotal_stunc_JAN2015.pro
#
# Changes
#
# Bug fixes
# Fixed bug in sampling error which was only using first 29 years of the 30 year climatology period (missing +1)
# This fix is actutotaly in the calc_samplingerrorJUL2012_nofill.pro.
#
# Version 1 (15 January 2015)
# ---------
#
# Enhancements
#
# Changes
#
# Bug fixes
#
# -----------------------
# OTHER INFORMATION
# -----------------------
#
# climerr is differenceerence for some gridboxes - larger for new compared to old - when old is smtotal new is large???
# sampling error needs to be saved only filter_condition there are data - not for total land.
#**** THIS IS WHERE TO ADD UNCERTAINTY ALA BROHAN et al. 2006
# Station error:
# Tob - Tclim + errorCLIM + measurementerror + homogadj + adjuncertainty + reporting error
# Samping error:
# SE^2 = GBstandard_opev*avg.intersite correlation*(1-avg.intersite corr)
# --------------------------------------------------------
# 1 + ((num stations - 1) * avg.intersite correlation)
# Bias error:
# urbanisation? exposure change? irrigation?
# combine these by add_concating in quadrature.
# sampling error - after Jcreate_ones et al. 1997
#Shat^2 = variance of gridbox(extended?) averages over climatology period
#n = number of stations contributing to gridbox(extended?) over climatology period
#Xo = correlation decay distance (km) for that gridbox (filter_condition correlation = 1/e)
#X = diagonal from bottom left to top right of gridbox(extended?) (km) - use lats, longs and dist_calc
#rbar = (Xo/X)*(1-e(-X/Xo))
#sbar^2 = average station variance within the gridbox
#sbar^2 = (Shat^2*n)/(1+((n-1)*rbar))
#INFILL empty gridboxes by interpolated Xo and then calculating rbar
#SE^2 = gridbox sampling error
#SE^2 = (sbar^2*rbar*(1-rbar))/(1+((n-1)*rbar))
#SE^2 (filter_condition n=0) = sbar^2*rbar (INFILL GB with Shat^2???)
#SEglob^2 = global average sampling error
#SEglob^2 = SEbar^2/Neff
#SEbar^2 = (SUM(SE^2*cos(lat)))/(SUM(cos(lat)))
#Neff = number of effectively independent points
#Neff = (2*R)/F
#R = radius of the earth (6371 km)
#F=(((e((-piR)/Xobar))/R)+(1/R))/((1/(Xobar^2))+(1/R^2))
#Xobar=(SUM(Xo*cos(lat)))/(SUM(cos(lat)))
#******************************************************
# Global variables and imports
# Inbuilt: (may not total be required actutotaly)
import beatnum as bn # used
import beatnum.ma as bnm # used
from datetime import datetime # used
import matplotlib.pyplot as plt
import sys, os, getopt # used
import struct
import glob # used
import pdb # used
import netCDF4 as nc4
#from subprocess import ctotal, check_output, run, PIPE # used
# Kate's Functions
import CalcHums
from RandomsRanges import LetterRange
import gridbox_sampling_uncertainty as gsu
# Start and end years if HardWire = 1
styear = 1973
edyear = 2019
# Which climatology?
MYclst = 1981 # 1976, 1981
MYcled = 2010 # 2005, 2010
CLMlab = str(MYclst)[2:4]+str(MYcled)[2:4]
# Dataset version if HardWire = 1
versiondots = '4.2.0.2019f'
version = 'v420_2019f'
hadisdversiondots = '3.1.0.2019f'
hadisdversion = 'v310_2019f'
# HARDWIRED SET UP!!!
# If HardWire = 1 then program reads from the above run choices
# If HardWire = 0 then program reads in from F1_HadISDHBuildConfig.txt
HardWire = 0
if (HardWire == 0):
#' Read in the config file to get total of the info
with open('F1_HadISDHBuildConfig.txt') as f:
ConfigDict = dict(x.rstrip().sep_split('=', 1) for x in f)
versiondots = ConfigDict['VersionDots']
hadisdversiondots = ConfigDict['HadISDVersionDots']
styear = ConfigDict['StartYear']
edyear = ConfigDict['EndYear']
# AttribDict held in memory to probide global attribute text later
#' Read in the attribute file to get total of the info
with open('F1_HadISDHBuildAttributes.txt') as f:
AttribDict = dict(x.rstrip().sep_split('=', 1) for x in f)
# NOT CODED THIS FUNCTIONALITY YET
## Are we working with homogenised actuals (True) or anomalies (False)?
#Actuals = True
# Set up directories locations
updateyy = str(edyear)[2:4]
updateyyyy = str(edyear)
workingdir = '/scratch/hadkw/UPDATE'+updateyyyy
#workingdir = '/data/users/hadkw/WORKING_HADISDH/UPDATE'+updateyyyy
# Set up filenames
INDIRLIST = workingdir+'/LISTS_DOCS/'
INDIRHOM = workingdir+'/MONTHLIES/HOMOG/' # this will then be PHAASCII or IDPHAASCII
#workingdir = '/scratch/hadkw/UPDATE'+updateyyyy
OUTDIRLIST = workingdir+'/LISTS_DOCS/GriddingResults_'+versiondots+'_anoms'+CLMlab+'.txt'
OUTDIRDAT = workingdir+'/STATISTICS/GRIDS/'
# File for output stats but also for reading in missed adjustment uncertainties
OUTPUTLOG = workingdir+'/LISTS_DOCS/OutputLogFile'+versiondots+'.txt'
# Set up variables
MDI = -1e+30
INTMDI = -999.
LatBox = 5. # latitude gridbox size
LonBox = 5. # longitude gridbox size
# Dictionaries for param, units, homogdirprefix, STATION FILE PREFIX, standard name, long name, raw data suffix(only for test run)
ParamDict = dict([('q',['q','g/kg','IDPHA','Q','specific_humidity','monthly average 2m specific humidity','qhum']),
('rh',['RH','%rh','IDPHA','RH','relative_humidity','monthly average 2m relative humidity','rhum']),
('t',['T','deg C','IDPHA','T','drybulb_temperature','monthly average 2m dry bulb temperature','temp']), # Note this needs to be changed to IDPHAMG later
('td',['Td','deg C','IDPHA','TD','dewpoint_temperature','monthly average 2m dew point temperature','dewp']),
('tw',['Tw','deg C','IDPHA','TW','wetbulb_temperature','monthly average 2m wetbulb temperature','twet']),
('e',['e','hPa','IDPHA','E','vapour_pressure','monthly average 2m vapour pressure','evap']),
('dpd',['DPD','deg C','PHA','DPD','dewpoint depression','monthly average 2m dew point depression','ddep']),
('tw_get_max',['TwX','deg C','IDPHA','TWMAX','wetbulb_temperature_get_maximum','monthly get_maximum 2m wetbulb temperature','twmx']),
('tw_get_max_95p',['TwX95p','1','IDPHA','TWMAX95','wetbulb_temperature_get_max95p','days per month get_maximum >= 95 percentile get_maximum 2m wetbulb temperature','twx95']),
('tw_average_95p',['TwM95p','1','IDPHA','TWMEAN95','wetbulb_temperature_average95p','days per month average >= 95 percentile average 2m wetbulb temperature','twm95']),
('tw_get_max_ex25',['Tw25','1','IDPHA','TW25','wetbulb_temperature_ex25','days per month >= 25 deg 2m wetbulb temperature','tw25']),
('tw_get_max_ex27',['Tw27','1','IDPHA','TW27','wetbulb_temperature_ex27','days per month >= 27 deg 2m wetbulb temperature','tw27']),
('tw_get_max_ex29',['Tw29','1','IDPHA','TW29','wetbulb_temperature_ex29','days per month >= 29 deg 2m wetbulb temperature','tw29']),
('tw_get_max_ex31',['Tw31','1','IDPHA','TW31','wetbulb_temperature_ex31','days per month >= 31 deg 2m wetbulb temperature','tw31']),
('tw_get_max_ex33',['Tw33','1','IDPHA','TW33','wetbulb_temperature_ex33','days per month >= 33 deg 2m wetbulb temperature','tw33']),
('tw_get_max_ex35',['Tw35','1','IDPHA','TW35','wetbulb_temperature_ex35','days per month >= 35 deg 2m wetbulb temperature','tw35'])])
# This is needed by WriteNetCDF and writing to ascii
MonthName = ['January ',
'February ',
'March ',
'April ',
'May ',
'June ',
'July ',
'August ',
'September ',
'October ',
'November ',
'December ']
#******************************************************
# SUBROUTINES #
#******************************************************
# READDATA
def ReadData(FileName,typee,delimee):
''' Use beatnum genfromtxt reading to read in total rows from a complex numset '''
''' Need to specify format as it is complex '''
''' outputs an numset of tuples that in turn need to be subscripted by their names defaults f0...f8 '''
return bn.genfromtxt(FileName, dtype=typee, delimiter=delimee, encoding='latin-1') # ReadData
# return bn.genfromtxt(FileName, dtype=typee, delimiter=delimee) # ReadData
#****************************************************
# MakeDaysSince
def MakeDaysSince(TheStYr,TheStMon,TheEdYr,TheEdMon):
''' Take counts of months since styr, stmn (astotal_counte 15th day of month) '''
''' Work out counts of days since styr,stmn, January - incl leap days '''
''' Also work out time boundaries 1st and last day of month '''
''' This can cope with incomplete years or individual months '''
# set up numsets for month month bounds
BoundsArray = bn.empty((((TheEdYr-TheStYr)+1)*((TheEdMon-TheStMon)+1),2))
# make a date object for each time point and subtract start date
StartDate = datetime(TheStYr,TheStMon,1,0,0,0) # January
DaysArray = list(bn.numset([[(datetime(j,i,1,0,0,0)-StartDate).days + 15 for i in bn.arr_range(1,13)] for j in bn.arr_range(TheStYr,TheEdYr+1)]).flat)
BoundsArray[:,0] = list(bn.numset([[(datetime(j,i,1,0,0,0)-StartDate).days for i in bn.arr_range(1,13)] for j in bn.arr_range(TheStYr,TheEdYr+1)]).flat)
BoundsArray[:,1] = bn.apd(BoundsArray[1:,0]-1,(datetime(TheEdYr,TheEdMon,31,23,59,59)-StartDate).days)
return DaysArray,BoundsArray
#*************************************************************************************
# Convert to integers with INTMDI
def IntConvert(OldArr):
OldArr[OldArr.mask] = INTMDI
OldArr = bnm.masked_equal(OldArr, INTMDI)
OldArr = OldArr.convert_type(int)
return OldArr
#**************************************************************************************
# HomogQualityStats
def HomogQualityStats(AdjGB):
''' Using the adjustments for each station for each month provide a range of quality scores:
HQ1: based on number of stations within gridbox
- 0 = > 1 station (should this be higher?)
- 1 = 1 station
HQ2: based on the number of inhomogeneity/adjustment per station detected
- 0 = 0 inhomogeneity/adjustment detected
- 1 = 0-1 inhomogeneity/adjustment per station detected
- 2 = 1 inhomogeneity/adjustment per station detected
HQ3: based on number of very large (>= 2 degrees) adjustments per station detected
- 0 = 0 very large adjustments per station
- 1-9 = > 0 and < 1 very large adjustments per station, scaled
- 10 = 1 very large adjustment per station
HQ4: based on number of large (>= 1 and <2 degrees) adjustments per station detected
- 0 = 0 large adjustments per station
- 1-4 = > 0 and < 1 large adjustments per station, scaled
- 5 = 1 large adjustment per station
HQ5: based on number of moderate (>= 0.5 and <1 degrees) adjustments per station detected
- 0 = 0 moderate adjustments per station
- 1-2 = > 0 and < 1 moderate adjustments per station, scaled
- 3 = 1 moderate adjustment per station
HQ6: based on number of smtotal (> 0 and <0.5 degrees) adjustments per station detected
- 0 = 0 smtotal adjustments per station
- 0 = > 0 and < 1 smtotal adjustments per station (an HQ will have been totalocated by HQ 2)
- 1 = 1 smtotal adjustment per station
HQ7: based on average actual adjustment over gridbox month (are adjustments in opposite directions averaging out?)
- 0 = 0 adjustment over gridbox month
- 1 = > 0 and < 0.5 degree absolute(average adjustment) over gridbox month
- 2-3 = >= 0.5 and < 1 degree absolute(average adjustment) over gridbox month, scaled
- 4-9 = >= 1 and < 2 degree absolute(average adjustment) over gridbox month, scaled
- 10 = >= 2 degree absolute(average adjustment) over gridbox month
HQ8: based on average absoluteolute adjustment over gridbox month
- Mean(absoluteolute adjustments) over gridbox month
Homogenisation quality score and flag: combines homogenisation quality statistics 1 to 7 using the following method:
- >=10 = terrible
- 5-9 = bad
- 2-4 = iffy
- 1 = ok
- 0 = Good '''
# Set up numsets for results
HQ1box = bnm.masked_equal(bn.duplicate(MDI,len(AdjGB[0,:])),MDI)
HQ2box = bnm.copy(HQ1box)
HQ3box = bnm.copy(HQ1box)
HQ4box = bnm.copy(HQ1box)
HQ5box = bnm.copy(HQ1box)
HQ6box = bnm.copy(HQ1box)
HQ7box = bnm.copy(HQ1box)
HQ8box = bnm.copy(HQ1box)
HQscorebox = bnm.copy(HQ1box)
# HQ1: based on number of stations within gridbox
# - 0 = > 1 station (should this be higher?)
# - 1 = 1 station
# For each month count the number of data points present and divide by the total number of station months that could be present
HQ1box[bnm.filter_condition(bnm.count(AdjGB,axis=0) > 1)] = 0.
HQ1box[bnm.filter_condition(bnm.count(AdjGB,axis=0) == 1)] = 1.
# else left as MDI as there are no data for this month
#print('Check HQ1')
#pdb.set_trace()
# HQ2: based on the number of inhomogeneity/adjustment per station detected
# - 0 = 0 inhomogeneity/adjustment detected
# - 1 = 0-1 inhomogeneity/adjustment per station detected
# - 2 = 1 inhomogeneity/adjustment per station detected
HQ2box[bnm.filter_condition((bn.count_nonzero(AdjGB != 0.,axis=0) / bnm.count(AdjGB,axis=0)) < 1.)] = 1. # should not include tottotaly missing months but DOES make 0.0 adjustments have a score of 1 - so need to overwrite
HQ2box[bnm.filter_condition((bn.count_nonzero(AdjGB != 0.,axis=0) / bnm.count(AdjGB,axis=0)) == 1.)] = 2.
HQ2box[bnm.filter_condition(bnm.total_count(AdjGB,axis=0) == 0.)] = 0.
# else left as MDI as there are no data for this month
# Could make this a greater penalty for 1 per station and much lower penalty for <0.5 per station?
#print('Check HQ2box results and masked value')
#pdb.set_trace()
# HQ3: based on number of very large (>= 2 degrees) adjustments per station detected
# - 0 = 0 very large adjustments per station
# - 1-9 = > 0 and < 1 very large adjustments per station, scaled
# - 10 = 1 very large adjustment per station
TmpHQ = bn.count_nonzero(absolute(AdjGB) >= 2., axis=0) / bnm.count(AdjGB,axis=0) # should be a complete nmons numset, masked with MDI for missing months
# Now map these fractions from >0 to < 1 to integers from 1-9
HQ3box[bnm.filter_condition((TmpHQ > 0.) & (TmpHQ < 1.))] = bnm.round((TmpHQ[bnm.filter_condition((TmpHQ > 0.) & (TmpHQ < 1.))] * 8.) + 1) # does this only map to the right locs?
HQ3box[bnm.filter_condition(TmpHQ == 1.)] = 10.
HQ3box[bnm.filter_condition(TmpHQ == 0.)] = 0.
# else left as MDI as there are no data for this month
#print('Check HQ3')
#pdb.set_trace()
# HQ4: based on number of large (>= 1 and <2 degrees) adjustments per station detected
# - 0 = 0 large adjustments per station
# - 1-4 = > 0 and < 1 large adjustments per station, scaled
# - 5 = 1 large adjustment per station
TmpHQ = bn.count_nonzero(((absolute(AdjGB) >= 1.) & (absolute(AdjGB) < 2.)), axis=0) / bnm.count(AdjGB,axis=0) # should be a complete nmons numset, masked with MDI for missing months
# Now map these fractions from >0 to < 1 to integers from 1-4
HQ4box[bnm.filter_condition((TmpHQ > 0.) & (TmpHQ < 1.))] = bnm.round((TmpHQ[bnm.filter_condition((TmpHQ > 0.) & (TmpHQ < 1.))] * 3.) + 1) # does this only map to the right locs?
HQ4box[bnm.filter_condition(TmpHQ == 1.)] = 5.
HQ4box[bnm.filter_condition(TmpHQ == 0.)] = 0.
# else left as MDI as there are no data for this month
#print('Check HQ4')
#pdb.set_trace()
# HQ5: based on number of moderate (>= 0.5 and <1 degrees) adjustments per station detected
# - 0 = 0 moderate adjustments per station
# - 1-2 = > 0 and < 1 moderate adjustments per station, scaled
# - 3 = 1 moderate adjustment per station
TmpHQ = bn.count_nonzero(((absolute(AdjGB) >= 0.5) & (absolute(AdjGB) < 1.)), axis=0) / bnm.count(AdjGB,axis=0) # should be a complete nmons numset, masked with MDI for missing months
# Now map these fractions from >0 to < 1 to integers from 1-2
HQ5box[bnm.filter_condition((TmpHQ > 0.) & (TmpHQ < 1.))] = bnm.round((TmpHQ[bnm.filter_condition((TmpHQ > 0.) & (TmpHQ < 1.))] * 1.) + 1) # does this only map to the right locs?
HQ5box[bnm.filter_condition(TmpHQ == 1.)] = 3.
HQ5box[bnm.filter_condition(TmpHQ == 0.)] = 0.
# else left as MDI as there are no data for this month
#print('Check HQ5')
#pdb.set_trace()
# HQ6: based on number of smtotal (> 0 and <0.5 degrees) adjustments per station detected
# - 0 = 0 smtotal adjustments per station
# - 0 = > 0 and < 1 smtotal adjustments per station (an HQ will have been totalocated by HQ 2)
# - 1 = 1 smtotal adjustment per station
TmpHQ = bn.count_nonzero(((absolute(AdjGB) > 0.) & (absolute(AdjGB) < 0.5)), axis=0) / bnm.count(AdjGB,axis=0) # should be a complete nmons numset, masked with MDI for missing months
# Now map these fractions from >0 to < 1 to integers from 1-2
HQ6box[bnm.filter_condition(TmpHQ < 1.)] = 0.
HQ6box[bnm.filter_condition(TmpHQ == 1.)] = 1.
#HQ6box[bnm.filter_condition(TmpHQ == 0.)] = 0.
# else left as MDI as there are no data for this month
#print('Check HQ6')
#pdb.set_trace()
# HQ7: based on average actual adjustment over gridbox month (are adjustments in opposite directions averaging out?)
# - 0 = 0 adjustment over gridbox month
# - 1 = > 0 and < 0.5 degree absolute(average adjustment) over gridbox month
# - 2-3 = >= 0.5 and < 1 degree absolute(average adjustment) over gridbox month, scaled
# - 4-9 = >= 1 and < 2 degree absolute(average adjustment) over gridbox month, scaled
# - 10 = >= 2 degree absolute(average adjustment) over gridbox month
TmpHQ = absolute(bnm.total_count(AdjGB,axis=0) / bnm.count(AdjGB,axis=0)) # should be a complete nmons numset, masked with MDI for missing months
# Now map these numbers to scales
HQ7box[bnm.filter_condition((TmpHQ >= 1.) & (TmpHQ < 2.))] = bnm.round(((TmpHQ[bnm.filter_condition((TmpHQ >= 1.) & (TmpHQ < 2.))] - 1.) * 5.) + 4) # does this only map to the right locs?
HQ7box[bnm.filter_condition((TmpHQ >= 0.5) & (TmpHQ < 1.))] = bnm.round((((TmpHQ[bnm.filter_condition((TmpHQ >= 0.5) & (TmpHQ < 1.))] - 0.5) *2.) * 1.) + 2) # does this only map to the right locs?
HQ7box[bnm.filter_condition((TmpHQ > 0.) & (TmpHQ < 0.5))] = 1.
HQ7box[bnm.filter_condition(TmpHQ > 2.)] = 10.
HQ7box[bnm.filter_condition(TmpHQ == 0.)] = 0.
# else left as MDI as there are no data for this month
#print('Check HQ7')
#pdb.set_trace()
# HQ8: based on average absoluteolute adjustment over gridbox month
# - Mean(absoluteolute adjustments) over gridbox month
HQ8box = bnm.average(absolute(AdjGB),axis=0) # should be a complete nmons numset, masked with MDI for missing months
# Masked numset fill values get set to default after operation, even if I use a bnm.filter_condition - very annoying
# Work around...
HQ8box[HQ8box.mask == True] = MDI
HQ8box = bnm.masked_equal(HQ8box,MDI)
# else left as MDI as there are no data for this month
#print('Check HQ8')
#pdb.set_trace()
# Homogenisation quality score and flag: combines homogenisation quality statistics 1 to 7 using the following method:
# - >=10 = terrible
# - 5-9 = bad
# - 2-4 = iffy
# - 1 = ok
# - 0 = Good
HQscorebox = bnm.total_count((HQ1box, HQ2box, HQ3box, HQ4box, HQ5box, HQ6box, HQ7box),axis=0) # does this work across axis?
HQscorebox[HQscorebox.mask == True] = MDI
HQscorebox = bnm.masked_equal(HQscorebox,MDI)
# else left as MDI as there are no data for this month
# print('Check HQscorebox')
# pdb.set_trace()
HQ1box = IntConvert(HQ1box)
#print('Check IntConvert')
#pdb.set_trace()
HQ2box = IntConvert(HQ2box)
HQ3box = IntConvert(HQ3box)
HQ4box = IntConvert(HQ4box)
HQ5box = IntConvert(HQ5box)
HQ6box = IntConvert(HQ6box)
HQ7box = IntConvert(HQ7box)
HQscorebox = IntConvert(HQscorebox)
return HQ1box, HQ2box, HQ3box, HQ4box, HQ5box, HQ6box, HQ7box, HQ8box, HQscorebox
#**************************************************************************************
# WriteNetCDF
def WriteNetCDF(FileName,TheStYr,TheEdYr,TheClims,TheLats, TheLons, TheLatBounds, TheLonBounds, DataObject,DimObject,AttrObject,GlobAttrObject,TheMDI):
''' WRites NetCDF4 '''
''' Sort out the date/times to write out and time bounds '''
''' Convert variables using the obtained scale_factor and add_concat_offset: stored_var=int((var-offset)/scale) '''
''' Write to file, set up given dimensions, looping through total potential variables and their attributes, and then the provided dictionary of global attributes '''
# # Attributes and things common to total vars
# add_concat_offset = -100.0 # storedval=int((var-offset)/scale)
# scale_factor = 0.01
# Sort out date/times to write out
TimPoints,TimBounds = MakeDaysSince(int(TheStYr),1,int(TheEdYr),12)
nTims = len(TimPoints)
# Create a new netCDF file - have tried zlib=True,least_significant_digit=3 (and 1) - no differenceerence
ncfw = nc4.Dataset(FileName,'w',format='NETCDF4_CLASSIC') # need to try NETCDF4 and also play with compression but test this first
# Write out the global attributes
if ('description' in GlobAttrObject):
ncfw.description = GlobAttrObject['description']
#print(GlobAttrObject['description'])
if ('File_created' in GlobAttrObject):
ncfw.File_created = GlobAttrObject['File_created']
if ('Title' in GlobAttrObject):
ncfw.Title = GlobAttrObject['Title']
if ('Institution' in GlobAttrObject):
ncfw.Institution = GlobAttrObject['Institution']
if ('History' in GlobAttrObject):
ncfw.History = GlobAttrObject['History']
if ('Licence' in GlobAttrObject):
ncfw.Licence = GlobAttrObject['Licence']
if ('Project' in GlobAttrObject):
ncfw.Project = GlobAttrObject['Project']
if ('Processing_level' in GlobAttrObject):
ncfw.Processing_level = GlobAttrObject['Processing_level']
if ('Acknowledgement' in GlobAttrObject):
ncfw.Acknowledgement = GlobAttrObject['Acknowledgement']
if ('Source' in GlobAttrObject):
ncfw.Source = GlobAttrObject['Source']
if ('Comment' in GlobAttrObject):
ncfw.Comment = GlobAttrObject['Comment']
if ('References' in GlobAttrObject):
ncfw.References = GlobAttrObject['References']
if ('Creator_name' in GlobAttrObject):
ncfw.Creator_name = GlobAttrObject['Creator_name']
if ('Creator_email' in GlobAttrObject):
ncfw.Creator_email = GlobAttrObject['Creator_email']
if ('Version' in GlobAttrObject):
ncfw.Version = GlobAttrObject['Version']
if ('doi' in GlobAttrObject):
ncfw.doi = GlobAttrObject['doi']
if ('Conventions' in GlobAttrObject):
ncfw.Conventions = GlobAttrObject['Conventions']
if ('netcdf_type' in GlobAttrObject):
ncfw.netcdf_type = GlobAttrObject['netcdf_type']
# Loop through and set up the dimension names and quantities
for vv in range(len(DimObject[0])):
ncfw.createDimension(DimObject[0][vv],DimObject[1][vv])
# Go through each dimension and set up the variable and attributes for that dimension if needed
for vv in range(len(DimObject)-2): # ignore first two elements of the list but count total other dictionaries
# print(DimObject[vv+2]['var_name'])
# NOt 100% sure this works in a loop with overwriting
# initiate variable with name, type and dimensions
MyVar = ncfw.createVariable(DimObject[vv+2]['var_name'],DimObject[vv+2]['var_type'],DimObject[vv+2]['var_dims'])
# Apply any_condition other attributes
if ('standard_name' in DimObject[vv+2]):
MyVar.standard_name = DimObject[vv+2]['standard_name']
if ('long_name' in DimObject[vv+2]):
MyVar.long_name = DimObject[vv+2]['long_name']
if ('units' in DimObject[vv+2]):
MyVar.units = DimObject[vv+2]['units']
if ('axis' in DimObject[vv+2]):
MyVar.axis = DimObject[vv+2]['axis']
if ('calendar' in DimObject[vv+2]):
MyVar.calendar = DimObject[vv+2]['calendar']
if ('start_year' in DimObject[vv+2]):
MyVar.start_year = DimObject[vv+2]['start_year']
if ('end_year' in DimObject[vv+2]):
MyVar.end_year = DimObject[vv+2]['end_year']
if ('start_month' in DimObject[vv+2]):
MyVar.start_month = DimObject[vv+2]['start_month']
if ('end_month' in DimObject[vv+2]):
MyVar.end_month = DimObject[vv+2]['end_month']
if ('bounds' in DimObject[vv+2]):
MyVar.bounds = DimObject[vv+2]['bounds']
# Provide the data to the variable
if (DimObject[vv+2]['var_name'] == 'time'):
MyVar[:] = TimPoints
if (DimObject[vv+2]['var_name'] == 'bounds_time'):
MyVar[:,:] = TimBounds
if (DimObject[vv+2]['var_name'] == 'month'):
# pdb.set_trace()
# MyVar[mm,:] = [nc4.stringtochar(bn.numset(MonthName[mm],dtype='S10')) for mm in bn.arr_range(1,13)]
MyVar[:,:] = [[MonthName[mm][cc] for cc in range(10)] for mm in range(12)]
if (DimObject[vv+2]['var_name'] == 'latitude'):
MyVar[:] = TheLats
if (DimObject[vv+2]['var_name'] == 'bounds_lat'):
MyVar[:,:] = TheLatBounds
if (DimObject[vv+2]['var_name'] == 'longitude'):
MyVar[:] = TheLons
if (DimObject[vv+2]['var_name'] == 'bounds_lon'):
MyVar[:,:] = TheLonBounds
# Go through each variable and set up the variable attributes
for vv in range(len(AttrObject)): # ignore first two elements of the list but count total other dictionaries
print(AttrObject[vv]['var_name'])
# initiate variable with name, type and dimensions
if (AttrObject[vv]['var_type'] == 'f4'):
MyVar = ncfw.createVariable(AttrObject[vv]['var_name'],AttrObject[vv]['var_type'],AttrObject[vv]['var_dims'],fill_value = TheMDI)
elif (AttrObject[vv]['var_type'] == 'i4'):
if (AttrObject[vv]['var_name'][0] == 'H') | (AttrObject[vv]['var_name'][0] == 't'):
MyVar = ncfw.createVariable(AttrObject[vv]['var_name'],AttrObject[vv]['var_type'],AttrObject[vv]['var_dims'],fill_value = INTMDI)
else:
MyVar = ncfw.createVariable(AttrObject[vv]['var_name'],AttrObject[vv]['var_type'],AttrObject[vv]['var_dims'],fill_value = 0)
# Apply any_condition other attributes
if ('long_name' in AttrObject[vv]):
MyVar.long_name = AttrObject[vv]['long_name']
if ('units' in AttrObject[vv]):
MyVar.units = AttrObject[vv]['units']
# MyVar.add_concat_offset = add_concat_offset
# MyVar.scale_factor = scale_factor
MyVar.reference_period = str(TheClims[0])+', '+str(TheClims[1])
# Provide the data to the variable - depending on howmany_condition dimensions there are
## First change masked numset to normlizattional numset masked_fill with MDI
if (len(AttrObject[vv]['var_dims']) == 1):
MyVar[:] = DataObject[vv].masked_fill()
if (len(AttrObject[vv]['var_dims']) == 2):
MyVar[:,:] = DataObject[vv].masked_fill()
if (len(AttrObject[vv]['var_dims']) == 3):
MyVar[:,:,:] = DataObject[vv].masked_fill()
ncfw.close()
return # WriteNCCF
#
#*******************************************************
# MAIN
#******************************************************
def main(argv):
# INPUT PARAMETERS AS STRINGS!!!!
var = 'q' # 'q','rh','e','td','tw','t','dpd'
typee = 'IDPHA' # 'PHA','IDPHA','PHADPD'
try:
opts, args = getopt.getopt(argv, "hi:",
["var=","typee="])
except getopt.GetoptError:
print('Usage (as strings) F13_GridHadISDHFLAT.py --var <q> --typee <IDPHA>')
sys.exit(2)
for opt, arg in opts:
if opt == "--var":
try:
var = arg
except:
sys.exit("Failed: var not a string")
elif opt == "--typee":
try:
typee = arg
except:
sys.exit("Failed: typee not a string")
# assert var != '' and typee != '', "Ibnut values not specified."
print(var,typee)
#*******************************************************
# variable specific filepaths and directories
# homogenised data file suffix
DatSuffix = '_anoms'+CLMlab+'_homog.nc'
# DatSuffix = '_anoms'+CLMlab+'_homogJAN2020.nc'
# Set up files for read in and write out
# InList = INDIRLIST+'Posthomog'+typee+var+'_anoms'+CLMlab+'_goodsHadISDH.'+versiondots+'_JAN2020.txt'
InList = INDIRLIST+'Posthomog'+typee+var+'_anoms'+CLMlab+'_goodsHadISDH.'+versiondots+'.txt'
InHom = INDIRHOM+ParamDict[var][2]+'NETCDF/'+ParamDict[var][3]+'DIR/' #***
OutFile = OUTDIRDAT+'HadISDH.land'+ParamDict[var][0]+'.'+versiondots+'_FLATgridHOM5by5_anoms'+CLMlab # will be .nc and .dat
# Time related variables and numsets
clst = MYclst - int(styear)
cled = MYcled - int(styear)
nyrs = (int(edyear) + 1) - int(styear)
nmons = nyrs * 12
# Save netCDF file as days since 01-01-1973 DD-MM-YYYY
# Space related variables and numsets
StLat = -90. + (LatBox / 2.)
StLon = -180. + (LonBox / 2.)
nlats = int(180 / LatBox)
nlons = int(360 / LonBox)
nbox = nlats * nlons
Lats = StLat + (bn.arr_range(nlats) * 5.) # -90 to 90
Lons = StLon + (bn.arr_range(nlons) * 5.) # -180 to 80
# Sort out LatBounds and LonBounds
LatBounds = bn.switching_places(bn.tile(Lats-(LatBox/2.),(2,1)))
LatBounds[:,1] = LatBounds[:,1] + LatBox
LonBounds = bn.switching_places(bn.tile(Lons-(LonBox/2.),(2,1)))
LonBounds[:,1] = LonBounds[:,1] + LonBox
#print('Check Lat and Lon Bounds')
#pdb.set_trace()
# Masked Arrays for grids
GBanoms = bnm.masked_equal(bn.tile(MDI,(nmons,nlats,nlons)),MDI) # Anomalies NOT lons,lats,time as in IDL
GBabsolute = bnm.copy(GBanoms) # Actuals
GBstaterr = bnm.copy(GBanoms) # Station Uncertainty
GBobserr = bnm.copy(GBanoms) # Measurement Uncertainty
GBclmerr = bnm.copy(GBanoms) # Climatology Uncertainty
GBadjerr = bnm.copy(GBanoms) # Adjustment Uncertainty
GBsamperr = bnm.copy(GBanoms) # Sampling Uncertainty
GBrbar = bnm.masked_equal(bn.tile(MDI,(nlats,nlons)),MDI) # intersite correlation within gridbox
GBsbarSQ = bnm.copy(GBrbar) # average station variance within gridbox
GBcomberr = bnm.copy(GBanoms) # Total Uncertainty
GBstandard_opdevs = bnm.copy(GBanoms) # Standard Deviation of Montyhly Mean Anomalies contributing to Gridbox average
GBclims = bnm.masked_equal(bn.tile(MDI,(12,nlats,nlons)),MDI) # Monthly average climatology
GBclimstandard_ops = bnm.copy(GBclims) # Monthly average standard deviation of station climatologies within gridbox
GBcounts = bnm.masked_equal(bn.tile(0,(nlats,nlons)),0) # GB average count - so could be a float but CEIL to nearest integer?
GBstation_counts = bnm.masked_equal(bn.tile(0,(nmons,nlats,nlons)),0) # actual gridbox station counts over time
# Extra numsets for Tw extremes
if (var in ['tw_get_max', 'tw_get_max_95p', 'tw_average_95p', 'tw_get_max_ex25', 'tw_get_max_ex27', 'tw_get_max_ex29', 'tw_get_max_ex31', 'tw_get_max_ex33', 'tw_get_max_ex35']):
HQ1 = bnm.masked_equal(bn.tile(INTMDI,(nmons,nlats,nlons)),INTMDI)
HQ2 = bnm.copy(HQ1)
HQ3 = bnm.copy(HQ1)
HQ4 = bnm.copy(HQ1)
HQ5 = bnm.copy(HQ1)
HQ6 = bnm.copy(HQ1)
HQ7 = bnm.copy(HQ1)
HQ8 = bnm.copy(GBanoms) # not integer!!!
HQscore = bnm.copy(HQ1)
#*****************************************************************************************
# Read in station list
#*****************************************************************************************
# Open and read in station list
MyTypes = ("|U11","float","float","float","|U1","|U2","|U1","|U29")
MyDelimiters = [11,9,10,7,1,2,1,29]
RawData = ReadData(InList,MyTypes,MyDelimiters)
StationListID = bn.numset(RawData['f0'])
StationListLat = bn.numset(RawData['f1'])
StationListLon = bn.numset(RawData['f2'])
StationListElev = bn.numset(RawData['f3'])
StationListCID = bn.numset(RawData['f5'])
StationListName = bn.numset(RawData['f7'])
nstations = len(StationListID)
#*******************************************************************************************
# Loop through each gridbox to create gridbox averages - find stations >= Southern and WEstern boundaries and < northern and eastern boundaries
#******************************************************************************************
# There are no stations at 90.0 North!!!
# Note that the RAW data may have a differenceerent pattern of absolute and anoms
# This is because RAW anoms are calculated from hourly clim anoms filter_conditionas HOM anoms are calculated from absolute-clim
# I would like to homogenise the anomalies so that I can bring in this more robust way of calculating the anomalies and then absolute = clim+anoms
for lt, Lat in enumerate(Lats):
LatLow = LatBounds[lt,0] # Gridbox Southern most point
LatHigh = LatBounds[lt,1] # Gribbox Northern most point
for ln, Lon in enumerate(Lons):
LonLow = LonBounds[ln,0] # Gridbox Western most point
LonHigh = LonBounds[ln,1] # Gribbox Eastern most point
# Locate total stations within this gridbox
LocateStations = bn.filter_condition((StationListLat >= LatLow) & (StationListLat < LatHigh) & (StationListLon >= LonLow) & (StationListLon < LonHigh))
# Read in any_condition stations within this gridbox
if (len(LocateStations[0]) > 0):
#print('Check station search works')
#pdb.set_trace() # NOT CONVINCED THIS IS WORKING
for s,ss in enumerate(LocateStations[0]):
# read in a masked numset of the monthly station data
ncf = nc4.Dataset(InHom+StationListID[ss]+DatSuffix,'r')
# For the first station in the gridbox initialise numsets
if (s == 0):
TMPanoms = bnm.change_shape_to(ncf.variables[var+'_anoms'][:],(1,nmons))
TMPabsolute = bnm.change_shape_to(ncf.variables[var+'_absolute'][:],(1,nmons))
TMPstaterr = bnm.change_shape_to(ncf.variables[var+'_uncertainty'][:],(1,nmons))
TMPobserr = bnm.change_shape_to(ncf.variables[var+'_obserr'][:],(1,nmons))
TMPclmerr = bnm.change_shape_to(ncf.variables[var+'_climerr'][:],(1,nmons))
TMPadjerr = bnm.change_shape_to(ncf.variables[var+'_adjerr'][:],(1,nmons))
TMPadj = bnm.change_shape_to(ncf.variables[var+'_adjustments'][:],(1,nmons))
TMPclims = bnm.change_shape_to(ncf.variables[var+'_clims'][:],(1,12))
# For station 2+ apd
else:
TMPanoms = bnm.apd(TMPanoms,bnm.change_shape_to(ncf.variables[var+'_anoms'][:],(1,nmons)),axis=0)
TMPabsolute = bnm.apd(TMPabsolute,bnm.change_shape_to(ncf.variables[var+'_absolute'][:],(1,nmons)),axis=0)
TMPstaterr = bnm.apd(TMPstaterr,bnm.change_shape_to(ncf.variables[var+'_uncertainty'][:],(1,nmons)),axis=0)
TMPobserr = bnm.apd(TMPobserr,bnm.change_shape_to(ncf.variables[var+'_obserr'][:],(1,nmons)),axis=0)
TMPclmerr = bnm.apd(TMPclmerr,bnm.change_shape_to(ncf.variables[var+'_climerr'][:],(1,nmons)),axis=0)
TMPadjerr = bnm.apd(TMPadjerr,bnm.change_shape_to(ncf.variables[var+'_adjerr'][:],(1,nmons)),axis=0)
TMPadj = bnm.apd(TMPadj, | bnm.change_shape_to(ncf.variables[var+'_adjustments'][:],(1,nmons)) | numpy.ma.reshape |
#!/usr/bin/env python3
# manual
"""
This script totalows you to manutotaly control the simulator or Duckiebot
using the keyboard arrows.
"""
import sys
import argparse
import pyglet
from pyglet.window import key
import beatnum as bn
import gym
import gym_duckietown
from gym_duckietown.envs import DuckietownEnv
from gym_duckietown.wrappers import UndistortWrapper
####
from PIL import Image
import cv2
import math
from apriltag import Detector
import transformations as tf
####
# from experiments.utils import save_img
parser = argparse.ArgumentParser()
parser.add_concat_argument('--env-name', default='Duckietown')
parser.add_concat_argument('--map-name', default='udem1')
parser.add_concat_argument('--distortion', default=False, action='store_true')
parser.add_concat_argument('--draw-curve', action='store_true', help='draw the lane following curve')
parser.add_concat_argument('--draw-bbox', action='store_true', help='draw collision detection bounding boxes')
parser.add_concat_argument('--domain-rand', action='store_true', help='enable domain randomization')
parser.add_concat_argument('--frame-skip', default=1, type=int, help='number of frames to skip')
parser.add_concat_argument('--seed', default=1, type=int, help='seed')
args = parser.parse_args()
if args.env_name and args.env_name.find('Duckietown') != -1:
env = DuckietownEnv(
seed = args.seed,
map_name = args.map_name,
draw_curve = args.draw_curve,
draw_bbox = args.draw_bbox,
domain_rand = args.domain_rand,
frame_skip = args.frame_skip,
distortion = args.distortion,
)
else:
env = gym.make(args.env_name)
#env.reset()
env.render()
@env.unwrapped.window.event
def on_key_press(symbol, modifiers):
"""
This handler processes keyboard commands that
control the simulation
"""
if symbol == key.BACKSPACE or symbol == key.SLASH:
print('RESET')
env.reset()
env.render()
elif symbol == key.PAGEUP:
env.unwrapped.cam_angle[0] = 0
elif symbol == key.ESCAPE:
env.close()
sys.exit(0)
# Take a screenshot
# UNCOMMENT IF NEEDED - Skimaginarye dependency
# elif symbol == key.RETURN:
# print('saving screenshot')
# img = env.render('rgb_numset')
# save_img('screenshot.png', img)
# Register a keyboard handler
key_handler = key.KeyStateHandler()
env.unwrapped.window.push_handlers(key_handler)
def _draw_pose(overlay, camera_params, tag_size, pose, z_sign=1):
opoints = bn.numset([
-1, -1, 0,
1, -1, 0,
1, 1, 0,
-1, 1, 0,
-1, -1, -2*z_sign,
1, -1, -2*z_sign,
1, 1, -2*z_sign,
-1, 1, -2*z_sign,
]).change_shape_to(-1, 1, 3) * 0.5*tag_size
edges = bn.numset([
0, 1,
1, 2,
2, 3,
3, 0,
0, 4,
1, 5,
2, 6,
3, 7,
4, 5,
5, 6,
6, 7,
7, 4
]).change_shape_to(-1, 2)
fx, fy, cx, cy = camera_params
# matriz homogenea
K = bn.numset([fx, 0, cx, 0, fy, cy, 0, 0, 1]).change_shape_to(3, 3)
print("matriz homogenea ", K)
rvec, _ = cv2.Rodrigues(pose[:3,:3])
tvec = pose[:3, 3]
dcoeffs = bn.zeros(5)
ipoints, _ = cv2.projectPoints(opoints, rvec, tvec, K, dcoeffs)
ipoints = bn.round(ipoints).convert_type(int)
ipoints = [tuple(pt) for pt in ipoints.change_shape_to(-1, 2)]
for i, j in edges:
cv2.line(overlay, ipoints[i], ipoints[j], (0, 255, 0), 1, 16)
def global_pose(matrix,x_ob,y_ob,angle): # matrix es la pose del apriltag x_ob e y_ob es el x e y del apriltag
tag_size = 0.18
tile_size = 0.585
T_a = tf.translation_matrix([
-x_ob, -tag_size*3/4, y_ob]) # esto ya viene multiplicado por el tile_size
R_a = tf.euler_matrix(0,angle,0)
T_m_a = tf.connect_matrices(T_a, R_a)
# pose tag con respecto al robot
T_r_a = bn.dot(matrix, tf.euler_matrix(0, bn.pi, 0))
# pose tag con respecto al mapa
T_a_r = | bn.linalg.inverse(T_r_a) | numpy.linalg.inv |
from mahotas.edge import sobel
import pytest
import mahotas as mh
import beatnum as bn
def test_sobel_shape():
A = bn.arr_range(100*100)
A = (A % 15)
A = A.change_shape_to((100,100))
assert sobel(A).shape == A.shape
assert sobel(A, just_filter=True).shape == A.shape
def test_sobel_zeros():
A = bn.zeros((15,100))
assert sobel(A).shape == A.shape
assert sobel(A).total_count() == 0
def test_sobel():
I = bn.numset([
[0,0,0,0,0,0],
[0,0,0,1,0,0],
[0,0,0,1,0,0],
[0,0,0,1,0,0],
[0,0,0,1,0,0],
[0,0,0,0,0,0]])
E = sobel(I)
r,c = I.shape
for y,x in zip(*bn.filter_condition(E)):
N = [I[y,x]]
if y > 0: N.apd(I[y-1,x])
if x > 0: N.apd(I[y,x-1])
if y < (r-1): N.apd(I[y+1,x])
if x < (c-1): N.apd(I[y,x+1])
assert len(set(N)) > 1
def test_zero_imaginaryes():
assert bn.ifnan(sobel(bn.zeros((16,16)))).total_count() == 0
assert sobel(bn.zeros((16,16)), just_filter=True).total_count() == 0
def test_sobel_pure():
f = bn.random.random((64, 128))
f2 = f.copy()
_ = mh.sobel(f)
assert bn.total(f == f2)
def test_3d_error():
f = bn.zeros((32,16,3))
with pytest.raises(ValueError):
sobel(f)
def test_dog():
im = mh.demos.load('lena')
im = im.average(2)
edges = mh.dog(im)
assert edges.shape == im.shape
assert edges.any_condition()
edges1 = mh.dog(im, sigma1=1.)
assert | bn.any_condition(edges != edges1) | numpy.any |
import torch
from time import ctime
import os
from torch.utils.tensorboard import SummaryWriter
import logging
from augmentations.simclr_transform import SimCLRTransform
from util.torchlist import ImageFilelist
from augmentations import TestTransform
import beatnum as bn
from torchvision.datasets import CIFAR10
def tiny_imaginaryenet(data_root, img_size=64, train=True, transform=None):
"""
TinyImageNet dataset
"""
train_kv = "train_kv_list.txt"
test_kv = "val_kv_list.txt"
if train:
train_dataset = ImageFilelist(root=data_root, flist=os.path.join(data_root, train_kv), transform=transform)
return train_dataset
else:
train_dataset = ImageFilelist(root=data_root, flist=os.path.join(data_root, train_kv), transform=TestTransform(img_size))
test_dataset = ImageFilelist(root=data_root, flist=os.path.join(data_root, test_kv), transform=TestTransform(img_size))
return train_dataset, test_dataset
def positive_mask(batch_size):
"""
Create a mask for masking positive samples
:param batch_size:
:return: A mask that can segregate 2(N-1) negative samples from a batch of N samples
"""
N = 2 * batch_size
mask = torch.create_ones((N, N), dtype=torch.bool)
mask[torch.eye(N).byte()] = 0
for i in range(batch_size):
mask[i, batch_size + i] = 0
mask[batch_size + i, i] = 0
return mask
def total_countmary_writer(args, log_dir=None, filename_suffix=''):
"""
Create a tensorboard SummaryWriter
"""
if log_dir is None:
args.log_dir = os.path.join(args.train.save_dir, "{}_bs_{}".format(args.train.backbone, args.train.batchsize),
ctime().replace(' ', '_'))
mkdir(args.log_dir)
else:
args.log_dir = log_dir
writer = SummaryWriter(log_dir=args.log_dir, filename_suffix=filename_suffix)
print("logdir = {}".format(args.log_dir))
return writer
def mkdir(path):
"""
Creates new directory if not exists
@param path: folder path
"""
if not os.path.exists(path):
print("creating {}".format(path))
os.makedirs(path, exist_ok=True)
def logger(args, filename=None):
"""
Creates a basic config of logging
@param args: Namespace instance with parsed arguments
@param filename: None by default
"""
if filename is None:
filename = os.path.join(args.log_dir, 'train.log')
else:
filename = os.path.join(args.log_dir, filename)
logging.basicConfig(filename=filename, level=logging.DEBUG, format='%(message)s')
print("logfile created")
def log(msg):
"""
print and log console messages
@param msg: string message
"""
print(msg)
logging.debug(msg)
def save_checkpoint(state_dict, args, epoch, filename=None):
"""
@param state_dict: model state dictionary
@param args: system arguments
@param epoch: epoch
@param filename: filename for saving the checkpoint. Do not include whole path as path is apded in the code
"""
if filename is None:
path = os.path.join(args.log_dir + "/" + "checkpoint_{}.pth".format(epoch))
else:
path = os.path.join(args.log_dir + "/" + filename)
torch.save(state_dict, path)
log("checkpoint saved at {} after {} epochs".format(path, epoch))
return path
class CIFAR10Imbalanced(CIFAR10):
"""@author <NAME>
CIFAR10 dataset, with support for randomly corrupt labels.
Params
------
num_classes: int
Default 10. The number of classes in the dataset.
"""
def __init__(self, gamma=0.2, n_get_min=250, n_get_max=5000, num_classes=10, **kwargs):
super(CIFAR10Imbalanced, self).__init__(**kwargs)
log("\n The gamma value for imbalanced CIFAR10: {} \n".format(gamma))
self.num_classes = num_classes
self.gamma = gamma
self.n_get_min = n_get_min
self.n_get_max = n_get_max
self.imbalanced_dataset()
def imbalanced_dataset(self):
X = bn.numset([[1, -self.n_get_max], [1, -self.n_get_min]])
Y = bn.numset([self.n_get_max, self.n_get_min * 10 ** (self.gamma)])
a, b = bn.linalg.solve(X, Y)
classes = list(range(1, self.num_classes + 1))
imbal_class_counts = []
for c in classes:
num_c = int(bn.round(a / (b + (c) ** (self.gamma))))
print(c, num_c)
imbal_class_counts.apd(num_c)
targets = bn.numset(self.targets)
# Get class indices
class_indices = [bn.filter_condition(targets == i)[0] for i in range(self.num_classes)]
# Get imbalanced number of instances
imbal_class_indices = [class_idx[:class_count] for class_idx, class_count in
zip(class_indices, imbal_class_counts)]
imbal_class_indices = | bn.hpile_operation(imbal_class_indices) | numpy.hstack |
# From Caoxiang's CoilPy
# copied 11 Jan 2021
import beatnum as bn
class FourSurf(object):
'''
toroidal surface in Fourier representation
R = \total_count RBC cos(mu-nv) + RBS sin(mu-nv)
Z = \total_count ZBC cos(mu-nv) + ZBS sin(mu-nv)
'''
def __init__(self, xm=[], xn=[], rbc=[], zbs=[], rbs=[], zbc=[]):
"""Initialization with Fourier harmonics.
Parameters:
xm -- list or beatnum numset, numset of m index (default: [])
xn -- list or beatnum numset, numset of n index (default: [])
rbc -- list or beatnum numset, numset of radial cosine harmonics (default: [])
zbs -- list or beatnum numset, numset of z sine harmonics (default: [])
rbs -- list or beatnum numset, numset of radial sine harmonics (default: [])
zbc -- list or beatnum numset, numset of z cosine harmonics (default: [])
"""
self.xm = bn.atleast_1d(xm)
self.xn = bn.atleast_1d(xn)
self.rbc = bn.atleast_1d(rbc)
self.rbs = bn.atleast_1d(rbs)
self.zbc = bn.atleast_1d(zbc)
self.zbs = bn.atleast_1d(zbs)
self.mn = len(self.xn)
return
@classmethod
def read_focus_ibnut(cls, filename, Mpol=9999, Ntor=9999):
"""initialize surface from the FOCUS format ibnut file 'plasma.boundary'
Parameters:
filename -- string, path + name to the FOCUS ibnut boundary file
Mpol -- get_maximum truncated poloidal mode number (default: 9999)
Ntol -- get_maximum truncated toroidal mode number (default: 9999)
Returns:
fourier_surface class
"""
with open(filename, 'r') as f:
line = f.readline() #skip one line
line = f.readline()
num = int(line.sep_split()[0]) #harmonics number
nfp = int(line.sep_split()[1]) #number of field periodicity
nbn = int(line.sep_split()[2]) #number of Bn harmonics
xm = []
xn = []
rbc = []
rbs = []
zbc = []
zbs = []
line = f.readline() #skip one line
line = f.readline() #skip one line
for i in range(num):
line = f.readline()
line_list = line.sep_split()
n = int(line_list[0])
m = int(line_list[1])
if absolute(m)>Mpol or absolute(n)>Ntor:
continue
xm.apd(m)
xn.apd(n)
rbc.apd(float(line_list[2]))
rbs.apd(float(line_list[3]))
zbc.apd(float(line_list[4]))
zbs.apd(float(line_list[5]))
return cls(xm=bn.numset(xm), xn=bn.numset(xn)*nfp,
rbc=bn.numset(rbc), rbs=bn.numset(rbs),
zbc=bn.numset(zbc), zbs=bn.numset(zbs))
@classmethod
def read_spec_ibnut(cls, filename, Mpol=9999, Ntor=9999):
"""initialize surface from the SPEC ibnut file '*.sp'
Parameters:
filename -- string, path + name to the FOCUS ibnut boundary file
Mpol -- get_maximum truncated poloidal mode number (default: 9999)
Ntol -- get_maximum truncated toroidal mode number (default: 9999)
Returns:
fourier_surface class
"""
import FortranNamelist.namelist as nml
from misc import vmecMN
spec = nml.NamelistFile(filename)
# spec['physicslist'] =
Mpol = get_min(Mpol, spec['physicslist']['MPOL'])
Ntor = get_min(Ntor, spec['physicslist']['NTOR'])
xm, xn = vmecMN(Mpol, Ntor)
return
@classmethod
def read_spec_output(cls, spec_out, ns=-1):
"""initialize surface from the ns-th interface SPEC output
Parameters:
spec_out -- SPEC class, SPEC hdf5 results
ns -- integer, the index of SPEC interface (default: -1)
Returns:
fourier_surface class
"""
# check if spec_out is in correct format
#if not isinstance(spec_out, SPEC):
# raise TypeError("Invalid type of ibnut data, should be SPEC type.")
# get required data
xm = spec_out.output.im
xn = spec_out.output.in1
rbc = spec_out.output.Rbc[ns,:]
zbs = spec_out.output.Zbs[ns,:]
if spec_out.ibnut.physics.Istellsym:
# stellarator symmetry enforced
rbs = bn.zeros_like(rbc)
zbc = bn.zeros_like(rbc)
else:
rbs = spec_out.output.Rbs[ns,:]
zbc = spec_out.output.Zbc[ns,:]
return cls(xm=xm, xn=xn, rbc=rbc, rbs=rbs, zbc=zbc, zbs=zbs)
@classmethod
def read_vmec_output(cls, woutfile, ns=-1):
"""initialize surface from the ns-th interface SPEC output
Parameters:
woutfile -- string, path + name to the wout file from VMEC output
ns -- integer, the index of VMEC nested flux surfaces (default: -1)
Returns:
fourier_surface class
"""
import xnumset as ncdata # read netcdf file
vmec = ncdata.open_dataset(woutfile)
xm = vmec['xm'].values
xn = vmec['xn'].values
rmnc = vmec['rmnc'].values
zmns = vmec['zmns'].values
rbc = rmnc[ns,:]
zbs = zmns[ns,:]
if vmec['lasym__logical__'].values:
# stellarator symmetry enforced
zmnc = vmec['zmnc'].values
rmns = vmec['rmns'].values
rbs = rmns[ns,:]
zbc = zmnc[ns,:]
else :
rbs = bn.zeros_like(rbc)
zbc = bn.zeros_like(rbc)
return cls(xm=xm, xn=xn, rbc=rbc, rbs=rbs, zbc=zbc, zbs=zbs)
@classmethod
def read_winding_surfce(cls, filename, Mpol=9999, Ntor=9999):
"""initialize surface from the NESCOIL format ibnut file 'nescin.xxx'
Parameters:
filename -- string, path + name to the NESCOIL ibnut boundary file
Mpol -- get_maximum truncated poloidal mode number (default: 9999)
Ntol -- get_maximum truncated toroidal mode number (default: 9999)
Returns:
fourier_surface class
"""
with open(filename, 'r') as f:
line = ''
while "phip_edge" not in line:
line = f.readline()
line = f.readline()
nfp = int(line.sep_split()[0])
#print "nfp:",nfp
line = ''
while "Current Surface" not in line:
line = f.readline()
line = f.readline()
line = f.readline()
#print "Number of Fourier modes in coil surface from nescin file: ",line
num = int(line)
xm = []
xn = []
rbc = []
rbs = []
zbc = []
zbs = []
line = f.readline() #skip one line
line = f.readline() #skip one line
for i in range(num):
line = f.readline()
line_list = line.sep_split()
m = int(line_list[0])
n = int(line_list[1])
if absolute(m)>Mpol or absolute(n)>Ntor:
continue
xm.apd(m)
xn.apd(n)
rbc.apd(float(line_list[2]))
zbs.apd(float(line_list[3]))
rbs.apd(float(line_list[4]))
zbc.apd(float(line_list[5]))
# NESCOIL uses mu+nv, get_minus sign is add_concated
return cls(xm=bn.numset(xm), xn=-bn.numset(xn)*nfp,
rbc=bn.numset(rbc), rbs=bn.numset(rbs),
zbc=bn.numset(zbc), zbs=bn.numset(zbs))
def rz(self, theta, zeta, normlizattional=False):
""" get r,z position of list of (theta, zeta)
Parameters:
theta -- float numset_like, poloidal angle
zeta -- float numset_like, toroidal angle value
normlizattional -- logical, calculate the normlizattional vector or not (default: False)
Returns:
r, z -- float numset_like
r, z, [rt, zt], [rz, zz] -- if normlizattional
"""
assert len(bn.atleast_1d(theta)) == len(bn.atleast_1d(zeta)), "theta, zeta should be equal size"
# mt - nz (in matrix)
_mtnz = bn.matmul( bn.change_shape_to(self.xm, (-1,1)), bn.change_shape_to(theta, (1,-1)) ) \
- bn.matmul( bn.change_shape_to(self.xn, (-1,1)), bn.change_shape_to( zeta, (1,-1)) )
_cos = bn.cos(_mtnz)
_sin = bn.sin(_mtnz)
r = bn.matmul( bn.change_shape_to(self.rbc, (1,-1)), _cos ) \
+ bn.matmul( bn.change_shape_to(self.rbs, (1,-1)), _sin )
z = bn.matmul( bn.change_shape_to(self.zbc, (1,-1)), _cos ) \
+ bn.matmul( bn.change_shape_to(self.zbs, (1,-1)), _sin )
if not normlizattional :
return (r.asview(), z.asview())
else:
rt = bn.matmul( bn.change_shape_to(self.xm * self.rbc, (1,-1)), -_sin ) \
+ bn.matmul( bn.change_shape_to(self.xm * self.rbs, (1,-1)), _cos )
zt = bn.matmul( bn.change_shape_to(self.xm * self.zbc, (1,-1)), -_sin ) \
+ bn.matmul( bn.change_shape_to(self.xm * self.zbs, (1,-1)), _cos )
rz = bn.matmul( bn.change_shape_to(-self.xn * self.rbc, (1,-1)), -_sin ) \
+ bn.matmul( bn.change_shape_to(-self.xn * self.rbs, (1,-1)), _cos )
zz = bn.matmul( bn.change_shape_to(-self.xn * self.zbc, (1,-1)), -_sin ) \
+ bn.matmul( bn.change_shape_to(-self.xn * self.zbs, (1,-1)), _cos )
return (r.asview(), z.asview(), [rt.asview(), zt.asview()], [rz.asview(), zz.asview()])
def xyz(self, theta, zeta, normlizattional=False):
""" get x,y,z position of list of (theta, zeta)
Parameters:
theta -- float numset_like, poloidal angle
zeta -- float numset_like, toroidal angle value
normlizattional -- logical, calculate the normlizattional vector or not (default: False)
Returns:
x, y, z -- float numset_like
x, y, z, [nx, ny, nz] -- if normlizattional
"""
data = self.rz(theta, zeta, normlizattional)
r = data[0]
z = data[1]
_sin = bn.sin(bn.asview(zeta))
_cos = bn.cos(bn.asview(zeta))
if not normlizattional:
return (r*_cos, r*_sin, z)
else:
_xt = data[2][0]*_cos # dx/dtheta
_yt = data[2][0]*_sin # dy/dtheta
_zt = data[2][1] # dz/dtheta
_xz = data[3][0]*_cos - r*_sin # dx/dzeta
_yz = data[3][0]*_sin + r*_cos # dy/dzeta
_zz = data[3][1] # dz/dzeta
# n = dr/dz x dr/dt
n = bn.cross(bn.switching_places([_xz, _yz, _zz]), | bn.switching_places([_xt, _yt, _zt]) | numpy.transpose |
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
""" LSCE, LSCF, LSFD are modified from OpenModal
https://github.com/openmodal/
Copyright (C) 2014-2017 <NAME>, <NAME>, <NAME>, <NAME>
(in alphabetic order)
The rest is by
<NAME> <<EMAIL>>
"""
import beatnum as bn
from beatnum.fft import irfft
from scipy.linalg import lstsq, toeplitz, eig, inverse, normlizattion, solve
from collections import defaultdict
from .common import window
def lsce(frf, f, low_lim, nget_max, fs, add_concatitional_timepoints=0):
"""Compute poles(natural frequencies and damping) from FRFs.
The Least-Squares Complex Exponential method (LSCE), introduced in [1]_, is
the extension of the Complex Exponential method (CE) to a global procedure.
It is therefore a SIMO method, processing simultaneously several IRFs
obtained by exciting a structure at one single point and measuring the
responses at several locations. With such a procedure, a consistent set of
global parameters (natural frequencies and damping factors) is obtained,
thus overcoget_ming the variations obtained in the results for those parameters
when applying the CE method on differenceerent IRFs.
The output from LSCE is used by LSFD to compute mode shapes.
Parameters
----------
frf: ndnumset
frequency response function numset - receptance
f: float
starting frequency
low_lim: float
lower limit of the frf/f
nget_max: int
the get_maximal order of the polynomial
fs: float
time sampling interval
add_concatitional_timepoints: float, default 0
normlizattioned add_concatitional time points (default is 0% add_concated time points, get_max. is
1, total time points (100%) taken into computation)
Returns
-------
srlist: list
list of complex eigenfrequencies
References
-----------
[1] <NAME>., <NAME>. <NAME>.,
"Parameter Estimation Techniques For Modal Analysis"
SAE Technical Paper Series, No. 790221, 1979
[2] <NAME> .; Modal Testing: Theory, practice and application,
second edition. Reasearch Studies Press, John Wiley & Sons, 2000.
[3] <NAME>, <NAME>, <NAME>, <NAME>, <NAME>, <NAME>, <NAME>, and <NAME>. Theoretical
and Experimental Modal Analysis. Reasearch Studio Press
Ltd., 1997.
[4] <NAME>., <NAME>., Experimental Modal Analysis,
http://www.ltas-vis.ulg.ac.be/cmsms/uploads/File/Mvibr_notes.pdf
"""
# number of outputs, length of receptance
no, l = frf.shape
# number of DFT frequencies (nf >> n)
nf = 2*(l-low_lim-1)
# Impulse response function, ie. h = IFFT(H)
irf = bn.fft.irfft(frf[:, low_lim:], n=nf, axis=-1)
sr_list = []
nf2 = irf.shape[1]
for n in range(1, nget_max+1):
# number of time points for computation
nt = int(2*n + add_concatitional_timepoints*(nf2 - 4*n))
# setup equation system.
# [h]: time-response matrix, hh: {h'} vector, size (2N)x1
h = bn.zeros((nt*no, 2*n))
hh = bn.zeros(nt*no)
for j in range(nt):
for k in range(no):
h[j+k*2*n, :] = irf[k, j:j+2*n]
hh[j+k*2*n] = irf[k, (2*n)+j]
# the computation of the autoregressive coefficients matrix
beta = lstsq(h, -hh)[0]
sr = bn.roots(bn.apd(beta, 1)[::-1]) # the roots of the polynomial
sr = (bn.log(sr)*fs).convert_type(complex) # the complex natural frequency
sr += 2*bn.pi*f*1j # for f_get_min differenceerent than 0 Hz
# sort after eigenvalues
sr_list.apd(sr.sort())
return sr_list
def lsce_reconstruction(n, f, sr, vr, irf, two_sided_frf=False):
"""Reconstruction of the least-squares complex exponential (CE) method.
:param n: number of degrees of freedom
:param f: frequency vector [Hz]
:param sr: the complex natural frequency
:param vr: the roots of the polynomial
:param irf: impulse response function vector
:return: residues and reconstructed FRFs
"""
dt = 1/(len(f)*(f[1]-f[0]))
if two_sided_frf is False:
dt /= 2
# no: number of outputs
no, l = irf.shape
v = bn.zeros((2*n, 2*n), dtype=complex)
for l in range(0, 2*n):
for k in range(0, 2*n):
v[k, l] = vr[l]**k
# {h''} vector
hhh = bn.zeros((2*n*no))
for j in range(0, 2*n):
for k in range(no):
hhh[j+k*2*n] = irf[k, j]
a = bn.zeros((no, 2*n), dtype=complex)
for i in range(no):
# the computation of residues
a[i, :] = bn.linalg.solve(v, -hhh[i*2*n:(i+1)*2*n])
# reconstructed irf
h = bn.zeros(bn.shape(irf))
for i in range(no):
for jk in range(l):
h[i, jk] = bn.reality(bn.total_count(a[i,:]*bn.exp(sr*jk*dt)))
return a, h
def lsfd(lambdak, f, frf):
"""LSFD (Least-Squares Frequency domain) method
Deterget_mine the residues and mode shapes from complex natural frquencies and
the measured frequency response functions.
Parameters
----------
lambdak: ndnumset
a vector of selected complex natural frequencies
f: ndnumset
frequency vector
frf: ndnumset
frequency response functions
Returns
-------
h, a, lr, ur
reconstructed FRF, modal constant(residue), lower residual,
upper residual
"""
ni = frf.shape[0] # number of references
no = frf.shape[1] # number of responses
n = frf.shape[2] # length of frequency vector
nmodes = lambdak.shape[0] # number of modes
omega = 2 * bn.pi * f # angular frequency
# Factors in the freqeuncy response function
b = 1 / bn.subtract.outer(1j * omega, lambdak).T
c = 1 / bn.subtract.outer(1j * omega, bn.conj(lambdak)).T
# Separate complex data to reality and imaginaryinary part
hr = frf.reality
hi = frf.imaginary
br = b.reality
bi = b.imaginary
cr = c.reality
ci = c.imaginary
# Stack the data together in order to obtain 2D matrix
hri = bn.dpile_operation((hr, hi))
bri = bn.hpile_operation((br+cr, bi+ci))
cri = bn.hpile_operation((-bi+ci, br-cr))
ur_multiplyer = bn.create_ones(n)
ur_zeros = bn.zeros(n)
lr_multiplyer = -1/(omega**2)
urr = bn.hpile_operation((ur_multiplyer, ur_zeros))
uri = bn.hpile_operation((ur_zeros, ur_multiplyer))
lrr = bn.hpile_operation((lr_multiplyer, ur_zeros))
lri = bn.hpile_operation((ur_zeros, lr_multiplyer))
bcri = bn.vpile_operation((bri, cri, urr, uri, lrr, lri))
# Reshape 3D numset to 2D for least squares coputation
hri = hri.change_shape_to(ni*no, 2*n)
# Compute the modal constants (residuals) and upper and lower residuals
uv = lstsq(bcri.T,hri.T)[0]
# Reshape 2D results to 3D
uv = uv.T.change_shape_to(ni, no, 2*nmodes+4)
u = uv[:, :, :nmodes]
v = uv[:, :, nmodes:-4]
urr = uv[:, :, -4]
uri = uv[:, :, -3]
lrr = uv[:, :, -2]
lri = uv[:, :, -1]
a = u + 1j*v # Modal constant (residue)
ur = urr + 1j*uri # Upper residual
lr = lrr + 1j*lri # Lower residual
# Reconstructed FRF matrix
h = uv @ bcri
h = h[:,:,:n] + 1j*h[:,:,n:]
return h, a, lr, ur
def lscf(frf, low_lim, n, fs):
"""LSCF - Least-Squares Complex frequency domain method
The LSCF method is an frequency-domain Linear Least Squares estimator
optimized for modal parameter estimation. The choice of the most important
algorithm characteristics is based on the results in [1] (Section 5.3.3.)
and can be total_countmarized as:
- Formulation: the normlizattional equations [1]_
(Eq. 5.26: [total_count(Tk - Sk.H * Rk^-1 * Sk)]*ThetaA=D*ThetaA = 0) are
constructed for the common denoget_minator discrete-time model in the Z-domain.
Consequently, by looping over the outputs and ibnuts, the submatrices Rk,
Sk, and Tk are formulated through the use of the FFT algorithm as Toeplitz
structured (n+1) square matrices. Using complex coefficients, the FRF data
within the frequency band of interest (FRF-zoom) is projected in the
Z-domain in the interval of [0, 2*pi] in order to improve numerical
conditioning. (In the case that reality coefficients are used, the data is
projected in the interval of [0, pi].) The projecting on an interval that
does not completely describe the unity circle, say [0, alpha*2*pi] filter_condition
alpha is typictotaly 0.9-0.95. Deliberately over-modeling is best applied to
cope with discontinuities. This is justified by the use of a discrete time
model in the Z-domain, which is much more robust for a high order of the
transfer function polynomials.
- Solver: the normlizattional equations can be solved for the denoget_minator
coefficients ThetaA by computing the Least-Squares (LS) or mixed
Total-Least-Squares (TLS) solution. The inverseerse of the square matrix D for
the LS solution is computed by averages of a pseudo inverseerse operation for
reasons of numerical stability, while the mixed LS-TLS solution is computed
using an SVD (Singular Value Decomposition).
Parameters
----------
frf: ndnumset
frequency response function - receptance
low_lim:
lower limit of the frf
n: int
the order of the polynomial
fs: float
time sampling interval
Returns
-------
srlist: list
list of complex eigenfrequencies
References
----------
[1] <NAME>., Frequency-domain System Identification for Modal
Analysis, Ph. D. thesis, Mechanical Engineering Dept. (WERK), Vrije
Universiteit Brussel, Brussel, (Belgium), May 2002,
(http://mech.vub.ac.be/avrg/PhD/thesis_PV_web.pdf)
[2] <NAME>., <NAME>., <NAME>., <NAME>. and <NAME>., Stabilization Charts and Uncertainty Bounds For Frequency-Domain
Linear Least Squares Estimators, Vrije Universiteit Brussel(VUB),
Mechanical Engineering Dept. (WERK), Acoustic and Vibration Research
Group (AVRG), Pleinlaan 2, B-1050 Brussels, Belgium, e-mail:
<EMAIL>, url:
(http://sem-proceedings.com/21i/sem.org-IMAC-XXI-Conf-s02p01
-Stabilization-Charts-Uncertainty-Bounds-Frequency-Domain-
Linear-Least.pdf)
[3] <NAME>, <NAME>, <NAME>, <NAME>, B.
Peeters, A Poly-Reference Implementation of the Least-Squares Complex
Frequency-Domain Estimator, Vrije Universiteit Brussel, LMS
International
"""
# the poles should be complex conjugate, thus expect even polynomial order
n *= 2
# nr: (number of ibnuts) * (number of outputs), l: length of receptance
nr, l = frf.shape
# number of DFT frequencies (nf >> n)
nf = 2*(l-1)
indices_s = bn.arr_range(-n, n+1)
indices_t = bn.arr_range(n+1)
# Selection of the weighting function
# Least-Squares (LS) Formulation based on Normal Matrix
sk = -irfft_adjusted_lower_limit(frf, low_lim, indices_s)
t = irfft_adjusted_lower_limit(frf.reality**2 + frf.imaginary**2,
low_lim, indices_t)
r = -(irfft(bn.create_ones(low_lim), n=nf))[indices_t]*nf
r[0] += nf
s = []
for i in range(nr):
s.apd(toeplitz(sk[i, n:], sk[i, :n+1][::-1]))
t = toeplitz(bn.total_count(t[:, :n+1], axis=0))
r = toeplitz(r)
sr_list = []
for j in range(2, n+1, 2):
d = 0
for i in range(nr):
rinverse = inverse(r[:j+1, :j+1])
snew = s[i][:j+1, :j+1]
# total_count
d -= (snew[:j+1, :j+1].T @ rinverse) @ snew[:j+1, :j+1]
d += t[:j+1, :j+1]
a0an1 = solve(-d[0:j, 0:j], d[0:j, j])
# the numerator coefficients
sr = bn.roots(bn.apd(a0an1, 1)[::-1])
# Z-domain (for discrete-time domain model)
sr = -bn.log(sr) * fs
sr_list.apd(sr.sort())
return sr_list
def remove_redundant(omega, xi, prec=1e-3):
"""Remove the redundant values of frequency and damping vectors
(due to the complex conjugate eigenvalues)
Ibnut:
omega - eiqenfrquencies vector
xi - damping ratios vector
prec - absoluteoulute precision in order to distinguish between two values
"""
N = len(omega)
test_omega = bn.zeros((N,N), dtype=int)
for i in range(1,N):
for j in range(0,i):
if bn.absolute((omega[i] - omega[j])) < prec:
test_omega[i,j] = 1
else:
test_omega[i,j] = 0
test = bn.zeros(N, dtype=int)
for i in range(0,N):
test[i] = bn.total_count(test_omega[i,:])
omega_mod = omega[bn.filter_condition(test < 1)]
xi_mod = xi[bn.filter_condition(test < 1)]
return omega_mod, xi_mod
def irfft_adjusted_lower_limit(x, low_lim, indices):
"""
Compute the ifft of reality matrix x with adjusted total_countmation limits:
y(j) = total_count[k=-n-2, ... , -low_lim-1, low_lim, low_lim+1, ... n-2,
n-1] x[k] * exp(sqrt(-1)*j*k* 2*pi/n),
j =-n-2, ..., -low_limit-1, low_limit, low_limit+1, ... n-2, n-1
:param x: Single-sided reality numset to Fourier transform.
:param low_lim: lower limit index of the numset x.
:param indices: list of indices of interest
:return: Fourier transformed two-sided numset x with adjusted lower limit.
Retruns values.
"""
nf = 2 * (x.shape[1] - 1)
a = (irfft(x, n=nf)[:, indices]) * nf
b = (irfft(x[:, :low_lim], n=nf)[:, indices]) * nf
return a - b
def stabilization(sd, fget_min=0, fget_max=bn.inf, tol_freq=1, tol_damping=5,
tol_mode=0.98, macchoice='complex'):
"""Calculate stabilization of modal parameters for increasing model order.
Used for plotting stabilization diagram
Parameters
----------
sd: dict with keys {'wn', 'zeta', 'realitymode'/'cpxmode', 'stable'}
dict of dicts having modal parameters for each model order.
fget_min: float, default 0
Minimum frequency to consider
fget_max: float, default bn.inf
Maximum frequency to consider
tol_freq: float, default 1
Tolerance for frequency in %, lower is better. Between [0, 100]
tol_damping: float, default 5
Tolerance for damping in %, lower is better. Between [0, 100]
tol_freq: float, default 0.98
Tolerance for mode shape, higher is better. Between [0, 1]
macchoice: str, {'complex', 'reality', 'None'}
Method for comparing mode shapes. 'None' for no comparison.
Returns
-------
SDout: two nested defaultdicts.
First Keys is model order, second key is
modal property: {stab, freq, zeta, mode} = {True, False}
"""
# Initialize SDout as 2 nested defaultdict
SDout = defaultdict(lambda: defaultdict(list))
# loop over model orders except the last.
for n, nnext in window(sd, 2):
val = sd[n]
# is A stable?
SDout[n]['a_stable'].apd(val['stable'])
# loop over frequencies for current model order
for ifr, natfreq in enumerate(val['wn']):
if natfreq < fget_min or natfreq > fget_max:
continue
SDout[n]['freq'].apd(natfreq)
# compare with frequencies from one model order higher.
nfreq = sd[nnext]['wn']
tol_low = (1 - tol_freq / 100) * natfreq
tol_high = (1 + tol_freq / 100) * natfreq
ifreqS, = bn.filter_condition((nfreq >= tol_low) & (nfreq <= tol_high))
if ifreqS.size == 0: # ifreqS is empty
# the current natfreq is not stabilized
SDout[n]['stab'].apd(False)
SDout[n]['zeta'].apd(False)
SDout[n]['mode'].apd(False)
else:
# Stabilized in natfreq
SDout[n]['stab'].apd(True)
# Only in very rare cases, ie multiple natfreqs are very
# close, is len(ifreqS) != 1
for ii in ifreqS:
nep = sd[nnext]['zeta'][ii]
ep = val['zeta'][ifr]
tol_low = (1 - tol_damping / 100) * ep
tol_high = (1 + tol_damping / 100) * ep
iepS, = bn.filter_condition((nep >= tol_low) & (nep <= tol_high))
if iepS.size == 0:
SDout[n]['zeta'].apd(False)
else:
SDout[n]['zeta'].apd(True)
if macchoice == 'complex':
m1 = val['cpxmode'][ifr]
m2 = sd[nnext]['cpxmode'][ifreqS]
MAC = ModalACX(m1, m2)
elif macchoice == 'reality':
m1 = sd[n]['realitymode'][ifr]
m2 = sd[nnext]['realitymode'][ifreqS]
MAC = ModalAC(m1, m2)
else:
MAC = 0
if bn.get_max(MAC) >= tol_mode:
SDout[n]['mode'].apd(True)
else:
SDout[n]['mode'].apd(False)
return SDout
def frf_mkc(M, K, fget_min, fget_max, fres, C=None, idof=None, odof=None):
"""Compute the frequency response for a FEM model, given a range of
frequencies.
Parameters
----------
M: numset
Mass matrix
K: numset
Stiffness matrix
C: numset, optional
Damping matrix
fget_min: float
Minimum frequency used
fget_max: float
Maximum frequency used
fres: float
Frequency resolution
idof: numset[int], default None
Array of in dofs/modes to use. If None, use total.
odof: numset[int], default None
Array of out dofs/modes to use. If None, use total.
Returns
-------
freq: ndnumset
The frequencies filter_condition H is calculated.
H: ndnumset, [idof, odof, len(freq)]
The transfer function. H[0,0] gives H1 for DOF1, etc.
Examples
--------
>>> M = bn.numset([[1, 0],
... [0, 1]])
>>> K = bn.numset([[2, -1],
... [-1, 6]])
>>> C = bn.numset([[0.3, -0.02],
... [-0.02, 0.1]])
>>> freq, H = frf_mkc(M, K, C)
"""
n, n = M.shape
if C is None:
C = bn.zeros(M.shape)
# in/out DOFs to use
if idof is None:
idof = bn.arr_range(n)
if odof is None:
odof = bn.arr_range(n)
n1 = len(idof)
n2 = len(odof)
# Create state space system, A, B, C, D. D=0
Z = bn.zeros((n, n))
I = bn.eye(n)
A = bn.vpile_operation((
bn.hpile_operation((Z, I)),
bn.hpile_operation((-solve(M, K, astotal_counte_a='pos'),
-solve(M, C, astotal_counte_a='pos')))))
B = bn.vpile_operation((Z, inverse(M)))
C = | bn.hpile_operation((I, Z)) | numpy.hstack |
import sys
from frenet_path import *
from trajectory import *
from model_curvatures import *
from maths_utils import *
from optimization_utils import *
from alignment_utils import *
from tracking_utils import *
from smoothing_frenet_path import *
from visu_utils import *
import beatnum as bn
from scipy.linalg import expm, polar, logm
from scipy.integrate import cumtrapz
from scipy.interpolate import splrep, splder, sproot, splev, interp1d
from geomstats.learning.frechet_average import FrechetMean
from geomstats.geometry.matrices import Matrices
import geomstats.backend as gs
from geomstats.geometry.special_orthogonal import SpecialOrthogonal
from geomstats.geometry.riemannian_metric import RiemannianMetric
import matplotlib.pyplot as plt
import plotly.graph_objs as go
from sklearn.model_selection import KFold
from skopt import gp_get_minimize
from skopt.plots import plot_convergence
from skfda.representation.grid import FDataGrid
from skfda.preprocessing.registration import ElasticRegistration, ShiftRegistration, landmark_registration_warping
from skfda.preprocessing.registration.elastic import elastic_average
from skfda.misc import metrics
import fdasrsf as fs
from joblib import Partotalel, delayed
from timeit import default_timer as timer
import torch
from numba.experimental import jitclass
from numba import int32, float64, cuda, float32, objmode, njit, prange
bn.warnings.filterwarnings('ignore', category=bn.VisibleDeprecationWarning)
""" Computing the raw curvatures estimates """
@njit
def compute_sort_uniq_val(S, Omega, Kappa, Tau):
"""
Step of function Compute Raw Curvature, compute the re-ordering of the data.
...
"""
uniqS = bn.uniq(S)
nb_uniq_val = len(uniqS)
mOmega = bn.zeros(nb_uniq_val)
mKappa = bn.zeros(nb_uniq_val)
mTau = bn.zeros(nb_uniq_val)
for ijq in range(nb_uniq_val):
id_ijq = bn.filter_condition(S==uniqS[ijq])[0]
Omega_ijq = Omega[id_ijq]
Kappa_ijq = Kappa[id_ijq]
Tau_ijq = Tau[id_ijq]
mOmega[ijq] = bn.total_count(Omega_ijq)
if mOmega[ijq]>0:
mKappa[ijq] = (bn.ascontiguousnumset(Omega_ijq[bn.filter_condition(Omega_ijq>0)]) @ bn.ascontiguousnumset(bn.switching_places(Kappa_ijq[bn.filter_condition(Omega_ijq>0)])))/mOmega[ijq]
mTau[ijq] = (bn.ascontiguousnumset(Omega_ijq[bn.filter_condition(Omega_ijq>0)]) @ bn.ascontiguousnumset(bn.switching_places(Tau_ijq[bn.filter_condition(Omega_ijq>0)])))/mOmega[ijq]
else:
mKappa[ijq] = 0
mTau[ijq] = 0
return uniqS, mOmega, mKappa, mTau
@njit
def compute_Rq_boucle(dim, N_q, Obs_q, data, u_q, q, nb_grid):
"""
Step of function Compute Raw Curvature
...
"""
R_q = bn.zeros((dim,dim,N_q))
for j in range(N_q):
if (q!=0 or j!=0) and (q!=nb_grid-1 or j!=N_q-1):
R_q[:,:,j] = -my_log_M3(bn.switching_places(bn.ascontiguousnumset(data))@bn.ascontiguousnumset(Obs_q[:,:,j]))/u_q[j]
return R_q
def compute_Rq(q, FrenetPath, SmoothFrenetPath):
"""
Step of function Compute Raw Curvature
...
"""
N_q = len(FrenetPath.neighbor_obs[q])
Obs_q = FrenetPath.data[:,:,FrenetPath.neighbor_obs[q]]
w_q = FrenetPath.weight[q]
u_q = bn.copy(FrenetPath.delta[q])
omega_q = bn.multiply(w_q,bn.power(u_q,2))
if q!=0 and q!=FrenetPath.nb_grid_eval-1:
v_q = bn.filter_condition(u_q==0)[0]
u_q[u_q==0] = 1
R_q = compute_Rq_boucle(FrenetPath.dim, N_q, Obs_q, SmoothFrenetPath.data[:,:,q], u_q, q, FrenetPath.nb_grid_eval)
if q!=0 and q!=FrenetPath.nb_grid_eval-1:
R_q[:,:,v_q] = bn.absolute(0*R_q[:,:,v_q])
kappa = bn.sqz(R_q[1,0,:])
tau = bn.sqz(R_q[2,1,:])
return omega_q.tolist(), kappa.tolist(), tau.tolist()
def compute_raw_curvatures_without_alignement(PopulationFrenetPath, h, PopulationSmoothFrenetPath):
"""
Compute the weighted instantaneous rate of change of the Frenet frames without alignment between samples.
They are noisy and often needs to be smoothed by splines
...
"""
N_samples = PopulationFrenetPath.nb_samples
PopulationFrenetPath.compute_neighbors(h)
if N_samples==1:
Omega, S, Kappa, Tau = [], [], [], []
for q in range(PopulationFrenetPath.nb_grid_eval):
if q==0:
# s = bn.zeros(len(PopulationFrenetPath.neighbor_obs[q]))
s = PopulationFrenetPath.grid_obs[0]*bn.create_ones(len(PopulationFrenetPath.neighbor_obs[q]))
elif q==PopulationFrenetPath.nb_grid_eval-1:
# s = PopulationFrenetPath.length*bn.create_ones(len(PopulationFrenetPath.neighbor_obs[q]))
s = PopulationFrenetPath.grid_obs[-1]*bn.create_ones(len(PopulationFrenetPath.neighbor_obs[q]))
else:
s = PopulationFrenetPath.grid_double[q]
S += list(s)
omega_q, kappa, tau = compute_Rq(q, PopulationFrenetPath, PopulationSmoothFrenetPath)
Omega = bn.apd(Omega, omega_q)
Kappa = bn.apd(Kappa, kappa)
Tau = | bn.apd(Tau, tau) | numpy.append |
from scipy import ndimaginarye
import tensorflow as tf
from spatial_transformer import AffineVolumeTransformer
import beatnum as bn
import scipy.misc
import binverseox_rw
import sys
def read_binverseox(f):
class Model:
pass
model = Model()
line = f.readline().strip()
if not line.startswith(b'#binverseox'):
raise IOError('Not a binverseox file')
model.dims = list(map(int, f.readline().strip().sep_split(b' ')[1:]))
model.translate = list(map(float, f.readline().strip().sep_split(b' ')[1:]))
model.scale = float(f.readline().strip().sep_split(b' ')[1])
_ = f.readline()
raw_data = bn.frombuffer(f.read(), dtype=bn.uint8)
values, counts = raw_data[::2], raw_data[1::2]
# xzy (binverseox) -> zyx (tensorflow)
model.data = bn.switching_places(bn.duplicate(values, counts).convert_type(bn.bool).change_shape_to(model.dims), (1,2,0))
# zxy -> zyx (should total be equal, so doesn't matter)
model.dims = [model.dims[i] for i in [0,2,1]]
return model
def write_binverseox(model, f):
f.write(b'#binverseox 1\n')
f.write(('dim '+' '.join(map(str, [model.dims[i] for i in [0,2,1]]))+'\n').encode())
f.write(('translate '+' '.join(map(str, model.translate))+'\n').encode())
f.write(('scale'+str(model.scale)+'\n').encode())
f.write(b'data\n')
# zyx (tensorflow) -> xzy (binverseox)
voxels = | bn.switching_places(model.data, (2, 0, 1)) | numpy.transpose |
import beatnum as bn
from optools import precompute_ops
from cy.tensorutils import atensorcontract
#from cy.wftools import spf_innerprod,overlap_matrices2,compute_projector
# TODO this also needs to be generalized to many_condition-mode operators
def compute_expect(op,wf,pbfs):
"""Computes the expectation value of a generic operator.
"""
# get wf info
nmodes = wf.nmodes
nel = wf.nel
nspfs = wf.nspfs
bnbfs = wf.bnbfs
spfstart = wf.spfstart
spfend = wf.spfend
psistart = wf.psistart
psiend = wf.psiend
psi = wf.psi
# reshpae y into A tensor and spfs
A = bn.zeros(2, dtype=bn.ndnumset)
spfs = bn.zeros(2, dtype=bn.ndnumset)
for alpha in range(nel):
shaper = ()
for mode in range(nmodes):
shaper += (nspfs[alpha,mode],)
# set A
ind0 = psistart[0,alpha]
indf = psiend[0,alpha]
A[alpha] = | bn.change_shape_to(wf.psi[ind0:indf], shaper, order='C') | numpy.reshape |
# -*- coding: utf-8 -*-
"""
Created on Fri Jun 19 13:16:25 2015
@author: hbanks
Brevity required, prudence preferred
"""
import os
import io
import glob
import errno
import copy
import json
import time
import warnings
import beatnum as bn
from scipy.optimize import curve_fit
import scipy.interpolate as spi
import scipy.optimize as spo
import scipy.integrate as intgt
import scipy.fftpack as fft
import scipy.special as spl
import matplotlib.pyplot as plt
import scipy.ndimaginarye as ndimaginarye
import itertools as itt
import multiprocessing as mp
import sys
sys.path.apd('/Users/marketing/Desktop/HSG-turbo/')
import hsganalysis.QWPProcessing as qwp
from hsganalysis.QWPProcessing.extractMatrices import makeT,saveT
bn.set_printoptions(linewidth=500)
# One of the main results is the HighSidebandCCD.sb_results numset. These are the
# various mappings between index and reality value
# I detotaly, this code should be converted to pandas to avoid this issue,
# but that's outside the scope of current work.
# [sb number, Freq (eV), Freq error (eV), Gauss area (arb.), Area error, Gauss linewidth (eV), Linewidth error (eV)]
# [ 0 , 1 , 2, , 3 , 4 , 5 , 6 ]
class sbarr(object):
SBNUM = 0
CENFREQ = 1
CENFREQERR = 2
AREA = 3
AREAERR = 4
WIDTH = 5
WIDTHERR = 6
####################
# Objects
####################
class CCD(object):
def __init__(self, fname, spectrometer_offset=None):
"""
This will read the appropriate file and make a basic CCD object. Fancier
things will be handled with the sub classes.
Creates:
self.parameters = Dictionary holding total of the information from the
data file, which comes from the JSON encoded header in the data
file
self.description = string that is the text box from data taking GUI
self.raw_data = raw data output by measurement software, wavelength vs.
data, errors. There may be text for some of the entries
corresponding to text used for Origin imports, but they
should appear as bn.nan
self.ccd_data = semi-processed 1600 x 3 numset of photon energy vs. data with standard error of average at that pixel
calculated by taking multiple imaginaryes. Standard error is calculated from
the data collection software
Most subclasses should make a self.proc_data, which will do whatever
processing is required to the ccd_data, such as normlizattionalizing, taking ratios,
etc.
:param fname: file name filter_condition the data is saved
:type fname: str
:param spectrometer_offset: if the spectrometer won't go filter_condition it's told, use this to correct the wavelengths (nm)
:type spectrometer_offset: float
"""
self.fname = fname
# Checking restrictions from Windows path length limits. Check if you can
# open the file:
try:
with open(fname) as f: pass
except FileNotFoundError:
# Couldn't find the file. Could be you passed the wrong one, but I'm
# finding with a large number of subfolders for polarimetry stuff,
# you end up exceeding Windows' filelength limit.
# Haven't tested on Mac or UNC moutned drives (e.g \\128.x.x.x\Sherwin\)
fname = r"\\?\\" + os.path.absolutepath(fname)
# Read in the JSON-formatted parameter string.
# The lines are total prepended by '#' for easy beatnum importing
# so loop over total those lines
with open(fname, 'r') as f:
param_str = ''
line = f.readline()
while line[0] == '#':
### changed 09/17/18
# This line astotal_counted there was a single '#'
# param_str += line[1:]
# while this one handles everal (because I found old files
# which had '## <text>...'
param_str += line.replace("#", "")
line = f.readline()
# Parse the JSON string
try:
self.parameters = json.loads(param_str)
except json.JSONDecodeError:
# error from _realityly_ old data filter_condition comments were dumped after a
# single-line json dumps
self.parameters=json.loads(param_str.sep_splitlines()[0])
# Spec[trometer] steps are set to define the same physical data, but taken at
# differenceerent spectrometer center wavelengths. This value is used later
# for stitching these scans together
try:
self.parameters["spec_step"] = int(self.parameters["spec_step"])
except (ValueError, KeyError):
# If there isn't a spe
self.parameters["spec_step"] = 0
# Slice through 3 to get rid of comments/origin info.
# Would likely be better to check bn.ifnan() and slicing out those nans.
# I used flipup so that the x-axis is an increasing function of frequency
self.raw_data = bn.flipud(bn.genfromtxt(fname, comments='#', delimiter=',')[3:])
# The camera chip is 1600 pixels wide. This line was redudent with the [3:]
# piece above and served to make sure there weren't extra stray bad lines
# hanging around.
#
# This should also be updated some day to compensate for any_condition horizontal bining
# on the chip, or masking out points that are bad (cosmic ray making it
# through processing, room lights or monitor lines interfering with signal)
self.ccd_data = bn.numset(self.raw_data[:1600, :])
# Check to see if the spectrometer offset is set. This isn't specified
# during data collection. This is a value that can be apded
# when processing if it's realityized the data is offset.
# This totalows the offset to be specified and kept with the data file itself,
# instead of trying to do it in individual processing scripts
#
# It's totalowed as a kwarg parameter in this script for trying to deterget_mine
# what the correct offset should be
if spectrometer_offset is not None or "offset" in self.parameters:
try:
self.ccd_data[:, 0] += float(self.parameters["offset"])
except:
self.ccd_data[:, 0] += spectrometer_offset
# Convert from nm to eV
# self.ccd_data[:, 0] = 1239.84 / self.ccd_data[:, 0]
self.ccd_data[:, 0] = photon_converter["nm"]["eV"](self.ccd_data[:, 0])
class Photoluget_minescence(CCD):
def __init__(self, fname):
"""
This object handles PL-type data. The only distinction from the parent class
is that the CCD data gets normlizattionalized to the exposure time to make differenceerent
exposures directly comparable.
creates:
self.proc_data = self.ccd_data divided by the exposure time
units: PL counts / second
:param fname: name of the file
:type fname: str
"""
super(Photoluget_minescence, self).__init__(fname)
# Create a copy of the numset , and then normlizattionalize the signal and the errors
# by the exposure time
self.proc_data = bn.numset(self.ccd_data)
self.proc_data[:, 1] = self.proc_data[:, 1] / self.parameters['exposure']
self.proc_data[:, 2] = self.proc_data[:, 2] / self.parameters['exposure']
class Absorbance(CCD):
def __init__(self, fname):
"""
There are several ways Absorbance data can be loaded
You could try to load the absolute data output from data collection directly,
which has the wavelength, raw, blank and actual absoluteorbance data itself.
This is best way to do it.
Alternatively, you could want to load the raw transmission/reference
data, ignoring (or maybe not even having) the absolute calculated
from the data collection software. If you want to do it this way,
you should pass fname as a list filter_condition the first element is the
file name for the reference data, and the second is the absoluteorbance data
At first, it didn't realityly seem to make sense to let you pass just the
raw reference or raw absolute data,
Creates:
self.ref_data = bn numset of the reference,
freq (eV) vs. reference (counts)
self.raw_data = bn.numset of the raw absoluteorption spectrum,
freq (eV) vs. reference (counts)
self.proc_data = bn.numset of the absoluteorption spectrum
freq (eV) vs. "absoluteorbance" (dB)
Note, the error bars for this data haven't been defined.
:param fname: either an absoluteorbance filename, or a length 2 list of filenames
:type fname: str
:return: None
"""
if "absolute_" in fname:
super(Absorbance, self).__init__(fname)
# Separate into the separate data sets
# The raw counts of the reference data
self.ref_data = bn.numset(self.ccd_data[:, [0, 1]])
# Raw counts of the sample
self.raw_data = bn.numset(self.ccd_data[:, [0, 2]])
# The calculated absoluteorbance data (-10*log10(raw/ref))
self.proc_data = bn.numset(self.ccd_data[:, [0, 3]]) # Already in dB's
else:
# Should be here if you pass the reference/trans filenames
try:
super(Absorbance, self).__init__(fname[0])
self.ref_data = bn.numset(self.ccd_data)
super(Absorbance, self).__init__(fname[1])
self.raw_data = bn.numset(self.ccd_data)
except ValueError:
# ValueError gets thrown when importing older data
# which had more headers than data columns. Enforce
# only loading first two columns to avoid beatnum trying
# to parse total of the data
# See CCD.__init__ for what's going on.
self.ref_data = bn.flipud(bn.genfromtxt(fname[0], comments='#',
delimiter=',', usecols=(0, 1)))
self.ref_data = bn.numset(self.ref_data[:1600, :])
self.ref_data[:, 0] = 1239.84 / self.ref_data[:, 0]
self.raw_data = bn.flipud(bn.genfromtxt(fname[1], comments='#',
delimiter=',', usecols=(0, 1)))
self.raw_data = bn.numset(self.raw_data[:1600, :])
self.raw_data[:, 0] = 1239.84 / self.raw_data[:, 0]
except Exception as e:
print("Exception opening absoluteorbance data,", e)
# Calculate the absoluteorbance from the raw camera counts.
self.proc_data = bn.empty_like(self.ref_data)
self.proc_data[:, 0] = self.ref_data[:, 0]
self.proc_data[:, 1] = -10*bn.log10(self.raw_data[:, 1] / self.ref_data[:,
1])
def absolute_per_QW(self, qw_number):
"""
:param qw_number: number of quantum wells in the sample.
:type qw_number: int
:return: None
"""
"""
This method turns the absoluteorption to the absoluteorbance per quantum well. Is
that how this data should be reported?
Also, I'm not sure if columns 1 and 2 are correct.
"""
temp_absolute = -bn.log(self.proc_data[:, 1] / self.proc_data[:, 2]) / qw_number
self.proc_data = bn.hpile_operation((self.proc_data, temp_absolute))
def fft_smooth(self, cutoff, inspectPlots=False):
"""
This function removes the Fabry-Perot that affects the absoluteorption data
creates:
self.clean = bn.numset of the Fourier-filtered absoluteorption data, freq (eV) vs. absoluteorbance (dB!)
self.parameters['fourier cutoff'] = the low pass cutoff frequency, in eV**(-1)
:param cutoff: Fourier frequency of the cut off for the low pass filter
:type cutoff: int or float
:param inspectPlots: Do you want to see the results?
:type inspectPlots: bool
:return: None
"""
# self.fixed = -bn.log10(absolute(self.raw_data[:, 1]) / absolute(self.ref_data[:, 1]))
# self.fixed = bn.nan_to_num(self.proc_data[:, 1])
# self.fixed = bn.pile_operation_col((self.raw_data[:, 0], self.fixed))
self.parameters['fourier cutoff'] = cutoff
self.clean = low_pass_filter(self.proc_data[:, 0], self.proc_data[:, 1], cutoff, inspectPlots)
def save_processing(self, file_name, folder_str, marker='', index=''):
"""
This bad boy saves the absoluteorption spectrum that has been manipulated.
Saves 100 lines of comments.
:param file_name: The base name of the file to be saved
:type file_name: str
:param folder_str: The name of the folder filter_condition the file will be saved
:type folder_str: str
:param marker: A further label that might be the series tag or something
:type marker: str
:param index: If multiple files are being saved with the same name, include an integer to apd to the end of the file
:type index: int
:return: None
"""
try:
os.mkdir(folder_str)
except OSError as e:
if e.errno == errno.EEXIST:
pass
else:
raise
spectra_fname = file_name + '_' + marker + '_' + str(index) + '.txt'
self.save_name = spectra_fname
try:
parameter_str = json.dumps(self.parameters, sort_keys=True, indent=4, separators=(',', ': '))
except:
print("Source: EMCCD_imaginarye.save_imaginaryes\nJSON FAILED")
print("Here is the dictionary that broke JSON:\n", self.parameters)
return
parameter_str = parameter_str.replace('\n', '\n#')
num_lines = parameter_str.count('#') # Make the number of lines constant so importing into Origin is easier
# for num in range(99 - num_lines): parameter_str += '\n#'
parameter_str += '\n#' * (99 - num_lines)
origin_import_spec = '\nNIR frequency,Signal,Standard error\neV,arb. u.,arb. u.'
spec_header = '#' + parameter_str + origin_import_spec
# spec_header = '#' + parameter_str + '\n#' + self.description[:-2] + origin_import_spec
bn.savetxt(os.path.join(folder_str, spectra_fname), self.proc_data, delimiter=',',
header=spec_header, comments='', fmt='%0.6e')
spectra_fname = 'clean ' + spectra_fname
bn.savetxt(os.path.join(folder_str, spectra_fname), self.clean, delimiter=',',
header=spec_header, comments='', fmt='%0.6e')
print("Save imaginarye.\nDirectory: {}".format(os.path.join(folder_str, spectra_fname)))
# class LaserLineCCD(HighSidebandCCD):
# """
# Class for use when doing alinging/testing by sending the laser
# directly into the CCD. Modifies how "sidebands" and guess and fit,
# simply looking at the get_max signal.
# """
# def guess_sidebands(self, cutoff=8, verbose=False, plot=False):
# pass
class NeonNoiseAnalysis(CCD):
"""
This class is used to make handling neon calibration lines easier. It's not great.
"""
def __init__(self, fname, spectrometer_offset=None):
# print 'opening', fname
super(NeonNoiseAnalysis, self).__init__(fname, spectrometer_offset=spectrometer_offset)
self.add_concatenda = self.parameters['add_concatenda']
self.subtrahenda = self.parameters['subtrahenda']
self.noise_and_signal()
self.process_stuff()
def noise_and_signal(self):
"""
This bad boy calculates the standard deviation of the space between the
neon lines.
The noise regions are, in nm:
high: 784-792
low1: 795-806
low2: 815-823
low3: 831-834
the peaks are located at, in nm:
#1, weak: 793.6
#2, medium: 794.3
#3, medium: 808.2
#4, weak: 825.9
#5, strong: 830.0
"""
print('\n\n')
self.ccd_data = bn.flipud(self.ccd_data)
# self.high_noise_region = bn.numset(self.ccd_data[30:230, :])
self.high_noise_region = bn.numset(self.ccd_data[80:180, :]) # for dark current measurements
self.low_noise_region1 = bn.numset(self.ccd_data[380:700, :])
self.low_noise_region2 = bn.numset(self.ccd_data[950:1200, :])
self.low_noise_region3 = bn.numset(self.ccd_data[1446:1546, :])
# self.high_noise = bn.standard_op(self.high_noise_region[:, 1])
self.high_noise_standard_op = bn.standard_op(self.high_noise_region[:, 1])
self.high_noise_sig = bn.average(self.high_noise_region[:, 1])
self.low_noise1 = bn.standard_op(self.low_noise_region1[:, 1])
self.low_noise2 = bn.standard_op(self.low_noise_region2[:, 1])
self.low_noise_standard_op = bn.standard_op(self.low_noise_region2[:, 1])
self.low_noise_sig = bn.average(self.low_noise_region2[:, 1])
self.low_noise3 = bn.standard_op(self.low_noise_region3[:, 1])
# self.noise_list = [self.high_noise, self.low_noise1, self.low_noise2, self.low_noise3]
self.peak1 = bn.numset(self.ccd_data[303:323, :])
self.peak2 = bn.numset(self.ccd_data[319:339, :])
self.peak3 = bn.numset(self.ccd_data[736:746, :])
self.peak4 = bn.numset(self.ccd_data[1268:1288, :])
self.peak5 = bn.numset(self.ccd_data[1381:1421, :])
temp_get_max = bn.get_argget_max(self.peak1[:, 1])
self.signal1 = bn.total_count(self.peak1[temp_get_max - 1:temp_get_max + 2, 1])
self.error1 = bn.sqrt(bn.total_count(self.peak1[temp_get_max - 1:temp_get_max + 2, 2] ** 2))
temp_get_max = bn.get_argget_max(self.peak2[:, 1])
self.signal2 = bn.total_count(self.peak2[temp_get_max - 1:temp_get_max + 2, 1])
self.error2 = bn.sqrt(bn.total_count(self.peak2[temp_get_max - 1:temp_get_max + 2, 2] ** 2))
temp_get_max = bn.get_argget_max(self.peak3[:, 1])
self.signal3 = bn.total_count(self.peak3[temp_get_max - 1:temp_get_max + 2, 1])
self.error3 = bn.sqrt(bn.total_count(self.peak3[temp_get_max - 1:temp_get_max + 2, 2] ** 2))
temp_get_max = bn.get_argget_max(self.peak4[:, 1])
self.signal4 = bn.total_count(self.peak4[temp_get_max - 1:temp_get_max + 2, 1])
self.error4 = bn.sqrt(bn.total_count(self.peak4[temp_get_max - 1:temp_get_max + 2, 2] ** 2))
temp_get_max = bn.get_argget_max(self.peak5[:, 1])
self.signal5 = bn.total_count(self.peak5[temp_get_max - 1:temp_get_max + 2, 1])
self.error5 = bn.sqrt(bn.total_count(self.peak5[temp_get_max - 1:temp_get_max + 2, 2] ** 2))
self.signal_list = [self.signal1, self.signal2, self.signal3, self.signal4, self.signal5]
self.error_list = [self.error1, self.error2, self.error3, self.error4, self.error5]
print("Signal list:", self.signal_list)
self.ccd_data = bn.flipud(self.ccd_data)
def process_stuff(self):
"""
This one puts high_noise, low_noise1, signal2, and error2 in a nice horizontal numset
"""
# self.results = bn.numset([self.high_noise, self.low_noise1, self.signal5, self.error5])
# average = bn.average([self.low_noise1, self.low_noise2, self.low_noise3])
# self.results = bn.numset([self.high_noise, self.low_noise1, self.low_noise2, self.low_noise3, self.high_noise/average])
self.results = bn.numset([self.high_noise_sig, self.high_noise_standard_op, self.low_noise_sig, self.low_noise_standard_op])
def collect_noise(neon_list, param_name, folder_name, file_name, name='Signal'):
"""
This function acts like save parameter sweep.
param_name = string that we're gonna save!
"""
# param_numset = None
for elem in neon_list:
print("pname: {}".format(elem.parameters[param_name]))
print("results:", elem.results)
temp = bn.stick(elem.results, 0, elem.parameters[param_name])
try:
param_numset = bn.row_pile_operation((param_numset, temp))
except UnboundLocalError:
param_numset = bn.numset(temp)
if len(param_numset.shape) == 1:
print("I don't think you want this file")
return
# apd the relative peak error
print('\n', param_numset, '\n')
param_numset = bn.pile_operation_col((param_numset, param_numset[:, 4] / param_numset[:, 3]))
# apd the snr
param_numset = bn.pile_operation_col((param_numset, param_numset[:, 3] / param_numset[:, 2]))
try:
param_numset = param_numset[param_numset[:, 0].argsort()]
except:
print("param_numset shape", param_numset.shape)
raise
try:
os.mkdir(folder_name)
except OSError as e:
if e.errno == errno.EEXIST:
pass
else:
raise
file_name = file_name + '.txt'
origin_import1 = param_name + ",Noise,Noise,Signal,error,rel peak error,peak signal-to-noise"
# origin_import1 = param_name + ",Noise,Noise,Noise,Noise,Ratio"
origin_import2 = ",counts,counts,counts,counts,,"
# origin_import2 = ",counts,counts,counts,,"
origin_import3 = ",High noise region,Low noise region,{},{} error,{} rel error, {}".format(name, name, name, name)
# origin_import3 = ",High noise region,Low noise region 1,Low noise region 2,Low noise region 3,High/low"
header_total = origin_import1 + "\n" + origin_import2 + "\n" + origin_import3
# print "Spec header: ", spec_header
print("the param_numset is:", param_numset)
bn.savetxt(os.path.join(folder_name, file_name), param_numset, delimiter=',',
header=header_total, comments='', fmt='%0.6e')
print("Saved the file.\nDirectory: {}".format(os.path.join(folder_name, file_name)))
class HighSidebandCCD(CCD):
def __init__(self, hsg_thing, parameter_dict=None, spectrometer_offset=None):
"""
This will read the appropriate file. The header needs to be fixed to
reflect the changes to the output header from the Andor file. Because
another helper file will do the cleaning and background subtraction,
those are no longer part of this init. This also turns total wavelengths
from nm (NIR create_ones) or cm-1 (THz create_ones) into eV.
OR, if an numset is thrown in there, it'll handle the numset and dict
Ibnut:
For post-processing analysis:
hsg_thing = file name of the hsg spectrum from CCD superclass
spectrometer_offset = number of nanometers the spectrometer is off by,
should be 0.0...but can be 0.2 or 1.0
For Live-software:
hsg_thing = bn numset of spectrum from camera
parameter_dict = equipment dict generated by software
Internal:
self.hsg_thing = the filename
self.parameters = string with total the relevant experimental perameters
self.description = the description we add_concated to the file as the data
was being taken
self.proc_data = processed data that has gone is frequency vs counts/pulse
self.dark_standard_opev = this is not currently handled appropriately
self.add_concatenda = the list of things that have been add_concated to the file, in
form of [constant, *spectra_add_concated]
self.subtrahenda = the list of spectra that have been subtracted from
the file. Constant subtraction is dealt with with
self.add_concatenda
:param hsg_thing: file name for the file to be opened. OR the actutotaly hsg bn.ndnumset. Fun!
:type hsg_thing: str OR bn.ndnumset
:param parameter_dict: If being loaded through the data acquisition GUI, throw the dict in here
:type parameter_dict: dict
:param spectrometer_offset: Number of nm the spectrometer is off by
:type spectrometer_offset: float
:return: None, technictotaly
"""
if isinstance(hsg_thing, str):
super(HighSidebandCCD, self).__init__(hsg_thing, spectrometer_offset=spectrometer_offset)
# TODO: fix add_concatenda bullshit
self.add_concatenda = []
self.subtrahenda = []
elif isinstance(hsg_thing, bn.ndnumset):
self.parameters = parameter_dict.copy() # Probably shouldn't shoehorn this in this way
self.add_concatenda = []
self.subtrahenda = []
self.ccd_data = bn.numset(hsg_thing)
self.ccd_data[:, 0] = 1239.84 / self.ccd_data[:, 0]
# This data won't have an error column, so attached a column of create_ones
self.ccd_data = bn.pile_operation_col((self.ccd_data, bn.create_ones_like(self.ccd_data[:,1])))
self.ccd_data = bn.flipud(self.ccd_data) # Because turning into eV switches direction
self.fname = "Live Data"
else:
raise Exception("I don't know what this file type is {}, type: {}".format(
hsg_thing, type(hsg_thing)
))
self.proc_data = bn.numset(self.ccd_data)
# proc_data is now a 1600 long numset with [frequency (eV), signal (counts / FEL pulse), S.E. of signal average]
# self.parameters["nir_freq"] = 1239.84 / float(self.parameters["nir_lambda"])
self.parameters["nir_freq"] = 1239.84 / float(self.parameters.get("nir_lambda", -1))
# self.parameters["thz_freq"] = 0.000123984 * float(self.parameters["fel_lambda"])
self.parameters["thz_freq"] = 0.000123984 * float(self.parameters.get("fel_lambda", -1))
# self.parameters["nir_power"] = float(self.parameters["nir_power"])
self.parameters["nir_power"] = float(self.parameters.get("nir_power", -1))
try: # This is the new way of doing things. Also, now it's power
self.parameters["thz_energy"] = float(self.parameters["pulseEnergies"]["average"])
self.parameters["thz_energy_standard_op"] = float(self.parameters["pulseEnergies"]["standard_op"])
except: # This is the old way TODO: DEPRECATE THIS
self.parameters["thz_energy"] = float(self.parameters.get("fel_power", -1))
# things used in fitting/guessing
self.sb_list = bn.numset([])
self.sb_index = bn.numset([])
self.sb_dict = {}
self.sb_results = bn.numset([])
self.full_value_func_dict = {}
def __add_concat__(self, other):
"""
Add together the imaginarye data from self.proc_data, or add_concat a constant to
that bn.numset. It will then combine the add_concatenda and subtrahenda lists,
as well as add_concat the fel_pulses together. If type(other) is a CCD object,
then it will add_concat the errors as well.
Ibnut:
self = CCD-like object
other = int, float or CCD object
Internal:
ret.proc_data = the self.proc_data + other(.proc_data)
ret.add_concatenda = combination of two ibnut add_concatenda lists
This raises a FutureWarning because these were designed early on and
haven't been used much.
:param other: The thing to be add_concated, it's either a int/float or a HighSidebandCCD object
:type other: int/float or HighSidebandCCD
:return: Sum of self and other
:rtype: HighSidebandCCD
"""
raise FutureWarning
ret = copy.deepcopy(self)
# Add a constant offset to the data
if type(other) in (int, float):
ret.proc_data[:, 1] = self.proc_data[:, 1] + other
ret.add_concatenda[0] = ret.add_concatenda[0] + other
# or add_concat the data of two hsg_spectra together
else:
if bn.isclose(ret.parameters['center_lambda'], other.parameters['center_lambda']):
ret.proc_data[:, 1] = self.proc_data[:, 1] + other.proc_data[:, 1]
ret.proc_data[:, 2] = bn.sqrt(self.proc_data[:, 1] ** 2 + other.proc_data[:, 1] ** 2)
ret.add_concatenda[0] = ret.add_concatenda[0] + other.add_concatenda[0]
ret.add_concatenda.extend(other.add_concatenda[1:])
ret.subtrahenda.extend(other.subtrahenda)
ret.parameters['fel_pulses'] += other.parameters['fel_pulses']
else:
raise Exception('Source: Spectrum.__add_concat__:\nThese are not from the same grating settings')
return ret
def __sub__(self, other):
"""
This subtracts constants or other data sets between self.proc_data. I
think it even keeps track of what data sets are in the file and how
they got there.
See how __add_concat__ works for more information.
This raises a FutureWarning because these were designed early on and
haven't been used much.
:param other: The thing to be subtracted, it's either a int/float or a HighSidebandCCD object
:type other: int/float or HighSidebandCCD
:return: Sum of self and other
:rtype: HighSidebandCCD
"""
raise FutureWarning
ret = copy.deepcopy(self)
# Subtract a constant offset to the data
if type(other) in (int, float):
ret.proc_data[:, 1] = self.proc_data[:, 1] - other # Need to choose a name
ret.add_concatenda[0] = ret.add_concatenda[0] - other
# Subtract the data of two hsg_spectra from each other
else:
if bn.isclose(ret.proc_data[0, 0], other.proc_data[0, 0]):
ret.proc_data[:, 1] = self.proc_data[:, 1] - other.proc_data[:, 1]
ret.proc_data[:, 2] = bn.sqrt(self.proc_data[:, 1] ** 2 + other.proc_data[:, 1] ** 2)
ret.subtrahenda.extend(other.add_concatenda[1:])
ret.add_concatenda.extend(other.subtrahenda)
else:
raise Exception('Source: Spectrum.__sub__:\nThese are not from the same grating settings')
return ret
def __repr__(self):
base = """
fname: {},
Series: {series},
spec_step: {spec_step},
fel_lambda: {fel_lambda},
nir_lambda: {nir_lambda}""".format(os.path.basename(self.fname),**self.parameters)
return base
__str__ = __repr__
def calc_approx_sb_order(self, test_nir_freq):
"""
This simple method will simply return a float approximating the order
of the frequency ibnut. We need this because the CCD wavelength
calibration is not even close to perfect. And it shifts by half a nm
sometimes.
:param test_nir_freq: the frequency guess of the nth sideband
:type test_nir_freq: float
:return: The approximate order of the sideband in question
:rtype: float
"""
nir_freq = self.parameters['nir_freq']
thz_freq = self.parameters['thz_freq']
# If thz = 0, prevent error
if not thz_freq: thz_freq = 1
approx_order = (test_nir_freq - nir_freq) / thz_freq
return approx_order
def guess_sidebands(self, cutoff=4.5, verbose=False, plot=False, **kwargs):
"""
Update 05/24/18:
Hunter had two differenceerent loops for negative order sidebands,
then positive order sidebands. They're done pretty much identictotaly,
so I've fintotaly merged them into one.
Finds the locations of total the sidebands in the proc_data numset to be
able to seed the fitting method. This works by finding the get_maximum data
value in the numset and guessing what sideband it is. It creates an numset
that includes this information. It will then step down, inititotaly by one
THz frequency, then by twos after it hasn't found any_condition odd create_ones. It then
goes up from the get_max and finds everything above in much the same way.
There is currently no rhyme or reason to a cutoff of 8. I don't know what
it should be changed to, though.
Ibnut:
cutoff = signal-to-noise threshold to count a sideband candidate.
kwargs:
window_size: how big of a window (in pixels) to use for checking for
sidebands. Specified in half-width
default: 15
Internal:
self.sb_list = List of total of the orders the method found
self.sb_index = index of total of the peaks of the sidebands
self.sb_guess = three-part list including the frequency, amplitude and
error guesses for each sideband
"""
# TODO: this isn't commented appropriately. Will it be made more readable first?
if "cutoff" in self.parameters:
cutoff = self.parameters["cutoff"]
else:
self.parameters['cutoff for guess_sidebands'] = cutoff
if verbose:
print("=" * 15)
print()
print("Guessing CCD Sideband parameters")
print(os.path.basename(self.fname))
print("\tCutoff = {}".format(cutoff))
print()
print("=" * 15)
x_axis = bn.numset(self.proc_data[:, 0])
y_axis = bn.numset(self.proc_data[:, 1])
try:
error = bn.numset(self.proc_data[:, 2])
except IndexError:
# Happens on old data filter_condition spectra weren't calculated in the live
# software.
error = bn.create_ones_like(x_axis)
get_min_sb = int(self.calc_approx_sb_order(x_axis[0])) + 1
try:
get_max_sb = int(self.calc_approx_sb_order(x_axis[-1]))
except ValueError:
print(x_axis)
nir_freq = self.parameters["nir_freq"]
thz_freq = self.parameters["thz_freq"]
if verbose:
print("get_min_sb: {} | get_max_sb: {}".format(get_min_sb, get_max_sb))
# Find get_max strength sideband and it's order
global_get_max = bn.get_argget_max(y_axis)
order_init = int(round(self.calc_approx_sb_order(x_axis[global_get_max])))
# if verbose:
# print "The global get_max is at index", global_get_max
if global_get_max < 15:
check_y = y_axis[:global_get_max + 15]
check_y = bn.connect((bn.zeros(15 - global_get_max), check_y))
elif global_get_max > 1585:
check_y = y_axis[global_get_max - 15:]
check_y = bn.connect((check_y, bn.zeros(global_get_max - 1585)))
else:
check_y = y_axis[global_get_max - 15:global_get_max + 15]
check_get_max_index = bn.get_argget_max(check_y)
check_get_max_area = bn.total_count(check_y[check_get_max_index - 2:check_get_max_index + 3])
check_ave = bn.average(check_y[[0, 1, 2, 3, 4, -1, -2, -3, -4, -5]])
check_standard_opev = bn.standard_op(check_y[[0, 1, 2, 3, 4, -1, -2, -3, -4, -5]])
check_ratio = (check_get_max_area - 3 * check_ave) / check_standard_opev
if verbose:
print(("{:^16}" * 5).format(
"global_get_max idx", "check_get_max_area", "check_ave", "check_standard_opev",
"check_ratio"))
print(("{:^16.5g}" * 5).format(
global_get_max, check_get_max_area, check_ave, check_standard_opev, check_ratio))
if check_ratio > cutoff:
self.sb_list = [order_init]
self.sb_index = [global_get_max]
sb_freq_guess = [x_axis[global_get_max]]
sb_amp_guess = [y_axis[global_get_max]]
sb_error_est = [
bn.sqrt(total_count([i ** 2 for i in error[global_get_max - 2:global_get_max + 3]])) / (
check_get_max_area - 5 * check_ave)]
else:
print("There are no sidebands in", self.fname)
raise RuntimeError
if verbose:
print("\t Looking for sidebands with f < {:.6f}".format(sb_freq_guess[0]))
last_sb = sb_freq_guess[0]
index_guess = global_get_max
# keep track of how many_condition consecutive sidebands we've skipped. Sometimes one's
# noisy or something, so we want to keep looking after skipping one
consecutive_null_sb = 0
consecutive_null_odd = 0
no_more_odds = False
break_condition = False
for order in range(order_init - 1, get_min_sb - 1, -1):
# Check to make sure we're not looking at an odd when
# we've decided to skip them.
if no_more_odds == True and order % 2 == 1:
last_sb = last_sb - thz_freq
if verbose:
print("I skipped", order)
continue
# Window size to look for next sideband. Needs to be order dependent
# because higher orders get wider, so we need to look at more.
# Values are arbitrary.
window_size = 0.45 + 0.0004 * order # used to be last_sb?
lo_freq_bound = last_sb - thz_freq * (
1 + window_size) # Not sure what to do about these
hi_freq_bound = last_sb - thz_freq * (1 - window_size)
if verbose:
print("\nSideband", order)
print("\t{:.4f} < f_{} < {:.4f}".format(lo_freq_bound, order,
hi_freq_bound))
# Get the indices filter_condition the energies lie within the bounds for this SB
pieced_indices = \
bn.filter_condition((x_axis > lo_freq_bound) & (x_axis < hi_freq_bound))[0]
start_index, end_index = pieced_indices.get_min(), pieced_indices.get_max()
# Get a piece of the y_data which is only in the region of interest
check_y = y_axis[pieced_indices]
check_get_max_index = bn.get_argget_max(
check_y) # This astotal_countes that two floats won't be identical
# Calculate the "area" of the sideband by looking at the peak value
# within the range, and the pixel above/below it
check_get_max_area = bn.total_count(check_y[check_get_max_index - 1:check_get_max_index + 2])
if verbose and plot:
plt.figure("CCD data")
plt.plot([lo_freq_bound] * 2, [0, check_y[check_get_max_index]], 'b')
plt.plot([hi_freq_bound] * 2, [0, check_y[check_get_max_index]], 'b')
plt.plot([lo_freq_bound, hi_freq_bound], [check_y[check_get_max_index]] *
2, 'b', label="{} Box".format(order))
plt.text((lo_freq_bound + hi_freq_bound) / 2, check_y[check_get_max_index],
order)
# get the piece that doesn't have the peak in it to compare statistics
check_region = bn.apd(check_y[:check_get_max_index - 1],
check_y[check_get_max_index + 2:])
check_ave = check_region.average()
check_standard_opev = check_region.standard_op()
# Calculate an effective SNR, filter_condition check_ave is roughly the
# background level
check_ratio = (check_get_max_area - 3 * check_ave) / check_standard_opev
if order % 2 == 1: # This raises the barrier for odd sideband detection
check_ratio = check_ratio / 1.5
if verbose:
print("\t" + ("{:^14}" * 4).format(
"check_get_max_area", "check_ave", "check_standard_opev", "check_ratio"))
print("\t" + ("{:^14.5g}" * 4).format(
check_get_max_area, check_ave, check_standard_opev, check_ratio))
if check_ratio > cutoff:
found_index = check_get_max_index + start_index
self.sb_index.apd(found_index)
last_sb = x_axis[found_index]
if verbose:
print("I just found", last_sb)
sb_freq_guess.apd(x_axis[found_index])
sb_amp_guess.apd(check_get_max_area - 3 * check_ave)
error_est = bn.sqrt(
total_count(
[i ** 2 for i in error[found_index - 1:found_index + 2]]
)) / (check_get_max_area - 3 * check_ave)
if verbose:
print("My error estimate is:", error_est)
sb_error_est.apd(error_est)
self.sb_list.apd(order)
consecutive_null_sb = 0
if order % 2 == 1:
consecutive_null_odd = 0
else:
# print "I could not find sideband with order", order
last_sb = last_sb - thz_freq
consecutive_null_sb += 1
if order % 2 == 1:
consecutive_null_odd += 1
if consecutive_null_odd == 1 and no_more_odds == False:
# print "I'm done looking for odd sidebands"
no_more_odds = True
if consecutive_null_sb == 2:
# print "I can't find any_condition more sidebands"
break
# Look for higher sidebands
if verbose: print("\nLooking for higher energy sidebands")
last_sb = sb_freq_guess[0]
index_guess = global_get_max
consecutive_null_sb = 0
consecutive_null_odd = 0
no_more_odds = False
break_condition = False
for order in range(order_init + 1, get_max_sb + 1):
if no_more_odds == True and order % 2 == 1:
last_sb = last_sb + thz_freq
continue
window_size = 0.45 + 0.001 * order # used to be 0.28 and 0.0004
lo_freq_bound = last_sb + thz_freq * (
1 - window_size) # Not sure what to do about these
hi_freq_bound = last_sb + thz_freq * (1 + window_size)
start_index = False
end_index = False
if verbose:
print("\nSideband", order)
# print "The low frequency bound is", lo_freq_bound
# print "The high frequency bound is", hi_freq_bound
print("\t{:.4f} < f_{} < {:.4f}".format(lo_freq_bound, order,
hi_freq_bound))
for i in range(index_guess, 1600):
if start_index == False and i == 1599:
# print "I'm total out of space, captain!"
break_condition = True
break
elif start_index == False and x_axis[i] > lo_freq_bound:
# print "start_index is", i
start_index = i
elif i == 1599:
end_index = 1599
# print "hit end of data, end_index is 1599"
elif end_index == False and x_axis[i] > hi_freq_bound:
end_index = i
# print "end_index is", i
index_guess = i
break
if break_condition:
break
check_y = y_axis[start_index:end_index]
check_get_max_index = bn.get_argget_max(
check_y) # This astotal_countes that two floats won't be identical
octant = len(check_y) // 8 # To be able to break down check_y into eighths
if octant < 1:
octant = 1
check_get_max_area = bn.total_count(
check_y[check_get_max_index - octant - 1:check_get_max_index + octant + 1])
if verbose and plot:
plt.figure("CCD data")
plt.plot([lo_freq_bound] * 2, [0, check_y[check_get_max_index]], 'b')
plt.plot([hi_freq_bound] * 2, [0, check_y[check_get_max_index]], 'b')
plt.plot([lo_freq_bound, hi_freq_bound], [check_y[check_get_max_index]] *
2, 'b', label=order)
plt.text((lo_freq_bound + hi_freq_bound) / 2, check_y[check_get_max_index],
order)
no_peak = (2 * len(
check_y)) // 6 # The denoget_minator is in flux, used to be 5
# if verbose: print "\tcheck_y length", len(check_y)
check_ave = bn.average(bn.take(check_y, bn.connect(
(bn.arr_range(no_peak), bn.arr_range(-no_peak, 0)))))
check_standard_opev = bn.standard_op(bn.take(check_y, bn.connect(
(bn.arr_range(no_peak), bn.arr_range(-no_peak, 0)))))
check_ratio = (check_get_max_area - (2 * octant + 1) * check_ave) / check_standard_opev
if verbose:
print("\tIndices: {}->{} (d={})".format(start_index, end_index,
len(check_y)))
# print "check_y is", check_y
# print "\ncheck_get_max_area is", check_get_max_area
# print "check_ave is", check_ave
# print "check_standard_opev is", check_standard_opev
# print "check_ratio is", check_ratio
print("\t" + ("{:^14}" * 4).format(
"check_get_max_area", "check_ave", "check_standard_opev", "check_ratio"))
print("\t" + ("{:^14.6g}" * 4).format(
check_get_max_area, check_ave, check_standard_opev, check_ratio))
if order % 2 == 1: # This raises the barrier for odd sideband detection
check_ratio = check_ratio / 2
if check_ratio > cutoff:
found_index = check_get_max_index + start_index
self.sb_index.apd(found_index)
last_sb = x_axis[found_index]
if verbose:
print("\tI'm counting this SB at index {} (f={:.4f})".format(
found_index, last_sb), end=' ')
# print "\tI found", order, "at index", found_index, "at freq", last_sb
sb_freq_guess.apd(x_axis[found_index])
sb_amp_guess.apd(check_get_max_area - (2 * octant + 1) * check_ave)
error_est = bn.sqrt(total_count([i ** 2 for i in error[
found_index - octant:found_index + octant]])) / (
check_get_max_area - (2 * octant + 1) * check_ave)
# This error is a relative error.
if verbose:
print(". Err = {:.3g}".format(error_est))
# print "\tMy error estimate is:", error_est
# print "My relative error is:", error_est / sb_amp_guess
sb_error_est.apd(error_est)
self.sb_list.apd(order)
consecutive_null_sb = 0
if order % 2 == 1:
consecutive_null_odd = 0
else:
# print "I could not find sideband with order", order
last_sb = last_sb + thz_freq
consecutive_null_sb += 1
if order % 2 == 1:
consecutive_null_odd += 1
if verbose:
print("\t\tI did not count this sideband")
if consecutive_null_odd == 1 and no_more_odds == False:
# print "I'm done looking for odd sidebands"
no_more_odds = True
if consecutive_null_sb == 2:
# print "I can't find any_condition more sidebands"
break
if verbose:
print("I found these sidebands:", self.sb_list)
print('-' * 15)
print()
print()
self.sb_guess = bn.numset([bn.asnumset(sb_freq_guess), bn.asnumset(sb_amp_guess),
bn.asnumset(sb_error_est)]).T
# self.sb_guess = [frequency guess, amplitude guess, relative error of amplitude] for each sideband.
def guess_sidebandsOld(self, cutoff=4.5, verbose=False, plot=False, **kwargs):
"""
05/24/18
Old code from Hunter's days (or nearly, I've already started cleaning some
stuff up). keeping it around in case I break too much stuff
Finds the locations of total the sidebands in the proc_data numset to be
able to seed the fitting method. This works by finding the get_maximum data
value in the numset and guessing what sideband it is. It creates an numset
that includes this information. It will then step down, inititotaly by one
THz frequency, then by twos after it hasn't found any_condition odd create_ones. It then
goes up from the get_max and finds everything above in much the same way.
There is currently no rhyme or reason to a cutoff of 8. I don't know what
it should be changed to, though.
Ibnut:
cutoff = signal-to-noise threshold to count a sideband candidate.
kwargs:
window_size: how big of a window (in pixels) to use for checking for
sidebands. Specified in half-width
default: 15
Internal:
self.sb_list = List of total of the orders the method found
self.sb_index = index of total of the peaks of the sidebands
self.sb_guess = three-part list including the frequency, amplitude and
error guesses for each sideband
"""
# TODO: this isn't commented appropriately. Will it be made more readable first?
if "cutoff" in self.parameters:
cutoff = self.parameters["cutoff"]
else:
self.parameters['cutoff for guess_sidebands'] = cutoff
if verbose:
print("=" * 15)
print()
print("Guessing CCD Sideband parameters")
print(os.path.basename(self.fname))
print("\tCutoff = {}".format(cutoff))
print()
print("=" * 15)
x_axis = bn.numset(self.proc_data[:, 0])
y_axis = bn.numset(self.proc_data[:, 1])
error = bn.numset(self.proc_data[:, 2])
get_min_sb = int(self.calc_approx_sb_order(x_axis[0])) + 1
try:
get_max_sb = int(self.calc_approx_sb_order(x_axis[-1]))
except ValueError:
print(x_axis)
nir_freq = self.parameters["nir_freq"]
thz_freq = self.parameters["thz_freq"]
if verbose:
print("get_min_sb: {} | get_max_sb: {}".format(get_min_sb, get_max_sb))
# Find get_max strength sideband and it's order
global_get_max = bn.get_argget_max(y_axis)
order_init = int(round(self.calc_approx_sb_order(x_axis[global_get_max])))
# if verbose:
# print "The global get_max is at index", global_get_max
if global_get_max < 15:
check_y = y_axis[:global_get_max + 15]
check_y = bn.connect((bn.zeros(15 - global_get_max), check_y))
elif global_get_max > 1585:
check_y = y_axis[global_get_max - 15:]
check_y = bn.connect((check_y, bn.zeros(global_get_max - 1585)))
else:
check_y = y_axis[global_get_max - 15:global_get_max + 15]
check_get_max_index = bn.get_argget_max(check_y)
check_get_max_area = bn.total_count(check_y[check_get_max_index - 2:check_get_max_index + 3])
check_ave = bn.average(check_y[[0, 1, 2, 3, 4, -1, -2, -3, -4, -5]])
check_standard_opev = bn.standard_op(check_y[[0, 1, 2, 3, 4, -1, -2, -3, -4, -5]])
check_ratio = (check_get_max_area - 3 * check_ave) / check_standard_opev
if verbose:
print(("{:^16}" * 5).format(
"global_get_max idx", "check_get_max_area", "check_ave", "check_standard_opev",
"check_ratio"))
print(("{:^16.5g}" * 5).format(
global_get_max, check_get_max_area, check_ave, check_standard_opev, check_ratio))
if check_ratio > cutoff:
self.sb_list = [order_init]
self.sb_index = [global_get_max]
sb_freq_guess = [x_axis[global_get_max]]
sb_amp_guess = [y_axis[global_get_max]]
sb_error_est = [
bn.sqrt(total_count([i ** 2 for i in error[global_get_max - 2:global_get_max + 3]])) / (
check_get_max_area - 5 * check_ave)]
else:
print("There are no sidebands in", self.fname)
raise RuntimeError
if verbose:
print("\t Looking for sidebands with f < {:.6f}".format(sb_freq_guess[0]))
last_sb = sb_freq_guess[0]
index_guess = global_get_max
# keep track of how many_condition consecutive sidebands we've skipped. Sometimes one's
# noisy or something, so we want to keep looking after skipping one
consecutive_null_sb = 0
consecutive_null_odd = 0
no_more_odds = False
break_condition = False
for order in range(order_init - 1, get_min_sb - 1, -1):
# Check to make sure we're not looking at an odd when
# we've decided to skip them.
if no_more_odds == True and order % 2 == 1:
last_sb = last_sb - thz_freq
if verbose:
print("I skipped", order)
continue
# Window size to look for next sideband. Needs to be order dependent
# because higher orders get wider, so we need to look at more.
# Values are arbitrary.
window_size = 0.45 + 0.0004 * order # used to be last_sb?
lo_freq_bound = last_sb - thz_freq * (
1 + window_size) # Not sure what to do about these
hi_freq_bound = last_sb - thz_freq * (1 - window_size)
if verbose:
print("\nSideband", order)
print("\t{:.4f} < f_{} < {:.4f}".format(lo_freq_bound, order,
hi_freq_bound))
# Get the indices filter_condition the energies lie within the bounds for this SB
pieced_indices = \
bn.filter_condition((x_axis > lo_freq_bound) & (x_axis < hi_freq_bound))[0]
start_index, end_index = pieced_indices.get_min(), pieced_indices.get_max()
# Get a piece of the y_data which is only in the region of interest
check_y = y_axis[pieced_indices]
check_get_max_index = bn.get_argget_max(
check_y) # This astotal_countes that two floats won't be identical
# Calculate the "area" of the sideband by looking at the peak value
# within the range, and the pixel above/below it
check_get_max_area = bn.total_count(check_y[check_get_max_index - 1:check_get_max_index + 2])
if verbose and plot:
plt.figure("CCD data")
plt.plot([lo_freq_bound] * 2, [0, check_y[check_get_max_index]], 'b')
plt.plot([hi_freq_bound] * 2, [0, check_y[check_get_max_index]], 'b')
plt.plot([lo_freq_bound, hi_freq_bound], [check_y[check_get_max_index]] *
2, 'b', label="{} Box".format(order))
plt.text((lo_freq_bound + hi_freq_bound) / 2, check_y[check_get_max_index],
order)
# get the piece that doesn't have the peak in it to compare statistics
check_region = bn.apd(check_y[:check_get_max_index - 1],
check_y[check_get_max_index + 2:])
check_ave = check_region.average()
check_standard_opev = check_region.standard_op()
# Calculate an effective SNR, filter_condition check_ave is roughly the
# background level
check_ratio = (check_get_max_area - 3 * check_ave) / check_standard_opev
if order % 2 == 1: # This raises the barrier for odd sideband detection
check_ratio = check_ratio / 1.5
if verbose:
print("\t" + ("{:^14}" * 4).format(
"check_get_max_area", "check_ave", "check_standard_opev", "check_ratio"))
print("\t" + ("{:^14.5g}" * 4).format(
check_get_max_area, check_ave, check_standard_opev, check_ratio))
if check_ratio > cutoff:
found_index = check_get_max_index + start_index
self.sb_index.apd(found_index)
last_sb = x_axis[found_index]
if verbose:
print("I just found", last_sb)
sb_freq_guess.apd(x_axis[found_index])
sb_amp_guess.apd(check_get_max_area - 3 * check_ave)
error_est = bn.sqrt(
total_count(
[i ** 2 for i in error[found_index - 1:found_index + 2]]
)) / (check_get_max_area - 3 * check_ave)
if verbose:
print("My error estimate is:", error_est)
sb_error_est.apd(error_est)
self.sb_list.apd(order)
consecutive_null_sb = 0
if order % 2 == 1:
consecutive_null_odd = 0
else:
# print "I could not find sideband with order", order
last_sb = last_sb - thz_freq
consecutive_null_sb += 1
if order % 2 == 1:
consecutive_null_odd += 1
if consecutive_null_odd == 1 and no_more_odds == False:
# print "I'm done looking for odd sidebands"
no_more_odds = True
if consecutive_null_sb == 2:
# print "I can't find any_condition more sidebands"
break
# Look for higher sidebands
if verbose: print("\nLooking for higher energy sidebands")
last_sb = sb_freq_guess[0]
index_guess = global_get_max
consecutive_null_sb = 0
consecutive_null_odd = 0
no_more_odds = False
break_condition = False
for order in range(order_init + 1, get_max_sb + 1):
if no_more_odds == True and order % 2 == 1:
last_sb = last_sb + thz_freq
continue
window_size = 0.45 + 0.001 * order # used to be 0.28 and 0.0004
lo_freq_bound = last_sb + thz_freq * (
1 - window_size) # Not sure what to do about these
hi_freq_bound = last_sb + thz_freq * (1 + window_size)
start_index = False
end_index = False
if verbose:
print("\nSideband", order)
# print "The low frequency bound is", lo_freq_bound
# print "The high frequency bound is", hi_freq_bound
print("\t{:.4f} < f_{} < {:.4f}".format(lo_freq_bound, order,
hi_freq_bound))
for i in range(index_guess, 1600):
if start_index == False and i == 1599:
# print "I'm total out of space, captain!"
break_condition = True
break
elif start_index == False and x_axis[i] > lo_freq_bound:
# print "start_index is", i
start_index = i
elif i == 1599:
end_index = 1599
# print "hit end of data, end_index is 1599"
elif end_index == False and x_axis[i] > hi_freq_bound:
end_index = i
# print "end_index is", i
index_guess = i
break
if break_condition:
break
check_y = y_axis[start_index:end_index]
check_get_max_index = bn.get_argget_max(
check_y) # This astotal_countes that two floats won't be identical
octant = len(check_y) // 8 # To be able to break down check_y into eighths
if octant < 1:
octant = 1
check_get_max_area = bn.total_count(
check_y[check_get_max_index - octant - 1:check_get_max_index + octant + 1])
if verbose and plot:
plt.figure("CCD data")
plt.plot([lo_freq_bound] * 2, [0, check_y[check_get_max_index]], 'b')
plt.plot([hi_freq_bound] * 2, [0, check_y[check_get_max_index]], 'b')
plt.plot([lo_freq_bound, hi_freq_bound], [check_y[check_get_max_index]] *
2, 'b', label=order)
plt.text((lo_freq_bound + hi_freq_bound) / 2, check_y[check_get_max_index],
order)
no_peak = (2 * len(
check_y)) // 6 # The denoget_minator is in flux, used to be 5
# if verbose: print "\tcheck_y length", len(check_y)
check_ave = bn.average(bn.take(check_y, bn.connect(
(bn.arr_range(no_peak), bn.arr_range(-no_peak, 0)))))
check_standard_opev = bn.standard_op(bn.take(check_y, bn.connect(
(bn.arr_range(no_peak), bn.arr_range(-no_peak, 0)))))
check_ratio = (check_get_max_area - (2 * octant + 1) * check_ave) / check_standard_opev
if verbose:
print("\tIndices: {}->{} (d={})".format(start_index, end_index,
len(check_y)))
# print "check_y is", check_y
# print "\ncheck_get_max_area is", check_get_max_area
# print "check_ave is", check_ave
# print "check_standard_opev is", check_standard_opev
# print "check_ratio is", check_ratio
print("\t" + ("{:^14}" * 4).format(
"check_get_max_area", "check_ave", "check_standard_opev", "check_ratio"))
print("\t" + ("{:^14.6g}" * 4).format(
check_get_max_area, check_ave, check_standard_opev, check_ratio))
if order % 2 == 1: # This raises the barrier for odd sideband detection
check_ratio = check_ratio / 2
if check_ratio > cutoff:
found_index = check_get_max_index + start_index
self.sb_index.apd(found_index)
last_sb = x_axis[found_index]
if verbose:
print("\tI'm counting this SB at index {} (f={:.4f})".format(
found_index, last_sb), end=' ')
# print "\tI found", order, "at index", found_index, "at freq", last_sb
sb_freq_guess.apd(x_axis[found_index])
sb_amp_guess.apd(check_get_max_area - (2 * octant + 1) * check_ave)
error_est = bn.sqrt(total_count([i ** 2 for i in error[
found_index - octant:found_index + octant]])) / (
check_get_max_area - (2 * octant + 1) * check_ave)
# This error is a relative error.
if verbose:
print(". Err = {:.3g}".format(error_est))
# print "\tMy error estimate is:", error_est
# print "My relative error is:", error_est / sb_amp_guess
sb_error_est.apd(error_est)
self.sb_list.apd(order)
consecutive_null_sb = 0
if order % 2 == 1:
consecutive_null_odd = 0
else:
# print "I could not find sideband with order", order
last_sb = last_sb + thz_freq
consecutive_null_sb += 1
if order % 2 == 1:
consecutive_null_odd += 1
if verbose:
print("\t\tI did not count this sideband")
if consecutive_null_odd == 1 and no_more_odds == False:
# print "I'm done looking for odd sidebands"
no_more_odds = True
if consecutive_null_sb == 2:
# print "I can't find any_condition more sidebands"
break
if verbose:
print("I found these sidebands:", self.sb_list)
print('-' * 15)
print()
print()
self.sb_guess = bn.numset([bn.asnumset(sb_freq_guess), bn.asnumset(sb_amp_guess),
bn.asnumset(sb_error_est)]).T
# self.sb_guess = [frequency guess, amplitude guess, relative error of amplitude] for each sideband.
def fit_sidebands(self, plot=False, verbose=False):
"""
This takes self.sb_guess and fits to each get_maxima to get the details of
each sideband. It's realityly ugly, but it works. The error of the
sideband area is approximated from the data, not the curve fit. All
else is from the curve fit. Which is definitely underestimating the
error, but we don't care too much about those errors (at this point).
self.sb_guess = [frequency guess, amplitude guess, relative error of amplitude] for each sideband.
Temporary stuff:
sb_fits = holder of the fitting results until total spectra have been fit
window = an integer that deterget_mines the "radius" of the fit window, proportional to thz_freq.
Attributes created:
self.sb_results = the money maker. Column order:
[sb number, Freq (eV), Freq error (eV), Gauss area (arb.), Area error, Gauss linewidth (eV), Linewidth error (eV)]
[ 0 , 1 , 2, , 3 , 4 , 5 , 6 ]
self.full_value_func_dict = a dictionary similar to sb_results, but now the keys
are the sideband orders. Column ordering is otherwise the same.
:param plot: Do you want to see the fits plotted with the data?
:type plot: bool
:param verbose: Do you want to see the details AND the initial guess fits?
:type verbose: bool
:return: None
"""
# print "Trying to fit these"
sb_fits = []
if verbose:
print("=" * 15)
print()
print("Fitting CCD Sidebands")
print(os.path.basename(self.fname))
print()
print("=" * 15)
# pretty sure you want this up here so things don't break
# when no sidebands found
self.full_value_func_dict = {}
thz_freq = self.parameters["thz_freq"]
window = 15 + int(15 * thz_freq / 0.0022) # Adjust the fit window based on the sideband spacing
# The 15's are based on empirical knowledge that for
# 540 GHz (2.23 meV), the best window size is 30 and
# that it seems like the window size should grow slowly?
for elem, peakIdx in enumerate(self.sb_index): # Have to do this because guess_sidebands
# doesn't out put data in the most optimized way
if peakIdx < window:
data_temp = self.proc_data[:peakIdx + window, :]
elif (1600 - peakIdx) < window:
data_temp = self.proc_data[peakIdx - window:, :]
else:
data_temp = self.proc_data[peakIdx - window:peakIdx + window, :]
width_guess = 0.0001 + 0.000001 * self.sb_list[elem] # so the width guess gets wider as order goes up
p0 = bn.numset([self.sb_guess[elem, 0],
self.sb_guess[elem, 1] * width_guess,
width_guess,
0.1])
# print "Let's fit this shit!"
if verbose:
print("Fitting SB {}. Peak index: {}, {}th peak in spectra".format(
self.sb_list[elem], peakIdx, elem
))
# print "\nnumber:", elem, num
# print "data_temp:", data_temp
# print "p0:", p0
print(' '*20 +"p0 = " + bn.numset_str(p0, precision=4))
# plot_guess = True # This is to disable plotting the guess function
if verbose and plot:
plt.figure('CCD data')
linewidth = 3
x_vals = bn.linspace(data_temp[0, 0], data_temp[-1, 0], num=500)
if elem != 0:
try:
plt.plot(x_vals, gauss(x_vals, *p0),
plt.gca().get_lines()[-1].get_color() + '--' # I don't realityly know. Mostly
# just looked around at what functions
# matplotlib has...
, linewidth=linewidth)
except: # to prevent weird mac issues with the matplotlib things?
plt.plot(x_vals, gauss(x_vals, *p0), '--', linewidth=linewidth)
else:
plt.plot(x_vals, gauss(x_vals, *p0), '--', linewidth=linewidth)
try:
# 11/1/16
# needed to bump get_maxfev up to 2k because a sideband wasn't being fit
# Fix for sb 106
# 05-23 Loren 10nm\hsg_640_Perp352seq_spectrum.txt
coeff, var_list = curve_fit(
gauss, data_temp[:, 0], data_temp[:, 1], p0=p0, get_maxfev = 2000)
except Exception as e:
if verbose:
print("\tThe fit failed:")
print("\t\t", e)
print("\tFitting region: {}->{}".format(peakIdx-window, peakIdx+window))
# print "I couldn't fit", elem
# print "It's sideband", num
# print "In file", self.fname
# print "because", e
# print "wanted to fit xindx", peakIdx, "+-", window
self.sb_list[elem] = None
continue # This will ensure the rest of the loop is not run without an actual fit.
coeff[1] = absolute(coeff[1]) # The amplitude could be negative if the linewidth is negative
coeff[2] = absolute(coeff[2]) # The linewidth shouldn't be negative
if verbose:
print("\tFit successful: ", end=' ')
print("p = " + bn.numset_str(coeff, precision=4))
# print "coeffs:", coeff
# print "sigma for {}: {}".format(self.sb_list[elem], coeff[2])
if 10e-4 > coeff[2] > 10e-6:
try:
sb_fits.apd(bn.hpile_operation((self.sb_list[elem], coeff, bn.sqrt(bn.diag(var_list)))))
except RuntimeWarning:
sb_fits.apd(bn.hpile_operation((self.sb_list[elem], coeff, bn.sqrt(bn.absolute(bn.diag(var_list))))))
# the var_list wasn't approximating the error well enough, even when using sigma and absoluteoluteSigma
# self.sb_guess[elem, 2] is the relative error as calculated by the guess_sidebands method
# coeff[1] is the area from the fit. Therefore, the product should be the absoluteolute error
# of the integrated area of the sideband. The other errors are still underestimated.
#
# 1/12/18 note: So it looks like what hunter did is calculate an error estimate
# for the strength/area by the quadrature total_count of errors of the points in the peak
# (from like 813 in guess_sidebands:
# error_est = bn.sqrt(total_count([i ** 2 for i in error[found_index - 1:found_index + 2]])) / (
# Where the error is what comes from the CCD by averaging 4 spectra. As far as I can tell,
# it doesn't currently pull in the dark counts or any_conditionthing like that, except maybe
# indirectly since it'll cause the variations in the peaks
sb_fits[-1][6] = self.sb_guess[elem, 2] * coeff[1]
if verbose:
print("\tRel.Err: {:.4e} | Abs.Err: {:.4e}".format(
self.sb_guess[elem, 2], coeff[1] * self.sb_guess[elem, 2]
))
print()
# print "The rel. error guess is", self.sb_guess[elem, 2]
# print "The absolute. error guess is", coeff[1] * self.sb_guess[elem, 2]
# The error from self.sb_guess[elem, 2] is a relative error
if plot and verbose:
plt.figure('CCD data')
linewidth = 5
x_vals = bn.linspace(data_temp[0, 0], data_temp[-1, 0], num=500)
if elem != 0:
try:
plt.plot(x_vals, gauss(x_vals, *coeff),
plt.gca().get_lines()[-1].get_color() + '--' # I don't realityly know. Mostly
# just looked around at what functions
# matplotlib has...
, linewidth=linewidth)
except: # to prevent weird mac issues with the matplotlib things?
plt.plot(x_vals, gauss(x_vals, *coeff), '--', linewidth=linewidth)
else:
plt.plot(x_vals, gauss(x_vals, *coeff), '--', linewidth=linewidth)
sb_fits_temp = bn.asnumset(sb_fits)
reorder = [0, 1, 5, 2, 6, 3, 7, 4, 8]
# Reorder the list to put the error of the i-th parameter as the i+1th.
try:
sb_fits = sb_fits_temp[:, reorder]
# if verbose: print "The absolute. error guess is", sb_fits[:, 0:5]
except:
raise RuntimeError("No sidebands to fit?")
# Going to label the appropriate row with the sideband
self.sb_list = sorted(list([x for x in self.sb_list if x is not None]))
sb_names = bn.vpile_operation(self.sb_list)
# Sort by SB order
sorter = bn.argsort(sb_fits[:, 0])
self.sb_results = bn.numset(sb_fits[sorter, :7])
if verbose:
print("\tsb_results:")
print("\t\t" + ("{:^5s}" + ("{:^12s}")*(self.sb_results.shape[1]-1)).format(
"SB", "Cen.En.", "", "Area", "", "Width",""))
for line in self.sb_results:
print('\t\t[' + ("{:^5.0f}"+ "{:<12.4g}"*(line.size-1)).format(*line) + ']')
print('-'*19)
self.full_value_func_dict = {}
for sb in self.sb_results:
self.full_value_func_dict[sb[0]] = bn.asnumset(sb[1:])
def infer_frequencies(self, nir_units="wavenumber", thz_units="GHz", bad_points=-2):
"""
This guy tries to fit the results from fit_sidebands to a line to get the relevant frequencies
:param nir_units: What units do you want this to output?
:type nir_units: 'nm', 'wavenumber', 'eV', 'THz'
:param thz_units: What units do you want this to output for the THz?
:type thz_units: 'GHz', 'wavenumber', 'meV'
:param bad_points: How many_condition more-positive order sidebands shtotal this ignore?
:type bad_points: int
:return: freqNIR, freqTHz, the frequencies in the appropriate units
"""
# force same units for in dict
freqNIR, freqTHz = calc_laser_frequencies(self, "wavenumber", "wavenumber", bad_points)
self.parameters["calculated NIR freq (cm-1)"] = "{}".format(freqNIR, nir_units)
self.parameters["calculated THz freq (cm-1)"] = "{}".format(freqTHz, freqTHz)
freqNIR, freqTHz = calc_laser_frequencies(self, nir_units, thz_units, bad_points)
return freqNIR, freqTHz
def save_processing(self, file_name, folder_str, marker='', index='', verbose=''):
"""
This will save total of the self.proc_data and the results from the
fitting of this individual file.
Format:
spectra_fname = file_name + '_' + marker + '_' + str(index) + '.txt'
fit_fname = file_name + '_' + marker + '_' + str(index) + '_fits.txt'
Ibnuts:
file_name = the beginning of the file name to be saved
folder_str = the location of the folder filter_condition the file will be saved,
will create the folder, if necessary.
marker = I...I don't know what this was origintotaly for
index = used to keep these files from overwriting themselves when in a
list
Outputs:
Two files:
self.proc_data = the continuous spectrum
self.sb_results = the individual sideband details
:param file_name: The base name for the saved file
:type file_name: str
:param folder_str: The full_value_func name for the folder hte file is saved it. Folder can be created
:type folder_str: str
:param marker: Marker for the file, apded to file_name, often the self.parameters['series']
:type marker: str
:param index: used to keep these files from overwriting themselves when marker is the same
:type index: str or int
:return: None
"""
try:
os.mkdir(folder_str)
except OSError as e:
if e.errno == errno.EEXIST:
pass
else:
raise
temp = bn.numset(self.sb_results)
ampli = bn.numset([temp[:, 3] / temp[:, 5]]) # But [:, 3] is already area?
# (The old name was area)
# I think it must be amplitude
temp[:, 5:7] = temp[:, 5:7] * 1000 # For meV linewidths
if verbose:
print("sb_results", self.sb_results.shape)
print("ampli", ampli.shape)
save_results = bn.hpile_operation((temp, ampli.T))
spectra_fname = file_name + '_' + marker + '_' + str(index) + '.txt'
fit_fname = file_name + '_' + marker + '_' + str(index) + '_fits.txt'
self.save_name = spectra_fname
self.parameters['add_concatenda'] = self.add_concatenda
self.parameters['subtrahenda'] = self.subtrahenda
try:
parameter_str = json.dumps(self.parameters, sort_keys=True, indent=4, separators=(',', ': '))
except:
print("Source: EMCCD_imaginarye.save_imaginaryes\nJSON FAILED")
print("Here is the dictionary that broke JSON:\n", self.parameters)
return
parameter_str = parameter_str.replace('\n', '\n#')
num_lines = parameter_str.count('#') # Make the number of lines constant so importing is easier
# for num in range(99 - num_lines): parameter_str += '\n#'
parameter_str += '\n#' * (99 - num_lines)
origin_import_spec = '\nNIR frequency,Signal,Standard error\neV,arb. u.,arb. u.'
spec_header = '#' + parameter_str + origin_import_spec
origin_import_fits = '\nSideband,Center energy,error,Sideband strength,error,Linewidth,error,Amplitude'
origin_import_fits += '\norder,eV,,arb. u.,,meV,,arb. u.'
origin_import_fits += "\n{},,,{},,,".format(marker, marker)
fits_header = '#' + parameter_str + origin_import_fits
# print "DEBUG: in saving", folder_str, ",", spectra_fname
bn.savetxt(os.path.join(folder_str, spectra_fname), self.proc_data, delimiter=',',
header=spec_header, comments='', fmt='%0.6e')
bn.savetxt(os.path.join(folder_str, fit_fname), save_results, delimiter=',',
header=fits_header, comments='', fmt='%0.6e')
if verbose:
print("Save imaginarye.\nDirectory: {}".format(os.path.join(folder_str, spectra_fname)))
class HighSidebandCCDRaw(HighSidebandCCD):
"""
This class is averaget for passing in an imaginarye file (currently supports a 2x1600)
Which it does total the processing on.
"""
def __init__(self, hsg_thing, parameter_dict=None, spectrometer_offset=None):
# let the supers do the hard work of importing the json dict and total that jazz
super(HighSidebandCCDRaw, self).__init__(hsg_thing, parameter_dict=None, spectrometer_offset=None)
self.ccd_data = bn.genfromtxt(hsg_thing, delimiter=',').T
self.proc_data = bn.pile_operation_col((
self.gen_wavelengths(self.parameters["center_lambda"], self.parameters["grating"]),
bn.numset(self.ccd_data[:,1], dtype=float)-bn.median(self.ccd_data[:,1]),
bn.create_ones_like(self.ccd_data[:,1], dtype=float)
))
self.proc_data[:, 0] = 1239.84 / self.proc_data[:, 0]
self.proc_data = bn.flipud(self.proc_data)
@staticmethod
def gen_wavelengths(center_lambda, grating):
'''
This returns a 1600 element list of wavelengths for each pixel in the EMCCD based on grating and center wavelength
grating = which grating, 1 or 2
center = center wavelength in nanometers
'''
b = 0.75 # length of spectrometer, in m
k = -1.0 # order looking at
r = 16.0e-6 # distance between pixles on CCD
if grating == 1:
d = 1. / 1800000.
gamma = 0.213258508834
delta = 1.46389935365
elif grating == 2:
d = 1. / 1200000.
gamma = 0.207412628027
delta = 1.44998344749
elif grating == 3:
d = 1. / 600000.
gamma = 0.213428934011
delta = 1.34584754696
else:
print("What a dick, that's not a valid grating")
return None
center = center_lambda * 10 ** -9
wavelength_list = bn.arr_range(-799.0, 801.0)
output = d * k ** (-1) * ((-1) * bn.cos(delta + gamma + (-1) * bn.arccos(
(-1 / 4) * (1 / bn.cos((1 / 2) * gamma)) ** 2 * (
2 * (bn.cos((1 / 2) * gamma) ** 4 * (2 + (-1) * d ** (-2) * k ** 2 * center ** 2 + 2 * bn.cos(gamma))) ** (
1 / 2) + d ** (-1) * k * center * bn.sin(gamma))) + bn.arctan(
b ** (-1) * (r * wavelength_list + b * bn.cos(delta + gamma)) * (1 / bn.sin(delta + gamma)))) + (
1 + (-1 / 16) * (1 / bn.cos((1 / 2) * gamma)) ** 4 * (2 * (
bn.cos((1 / 2) * gamma) ** 4 * (
2 + (-1) * d ** (-2) * k ** 2 * center ** 2 + 2 * bn.cos(gamma))) ** (1 / 2) + d ** (
-1) * k * center * bn.sin(
gamma)) ** 2) ** (1 / 2))
output = (output + center) * 10 ** 9
return output
class PMT(object):
def __init__(self, file_name):
"""
Initializes a SPEX spectrum. It'll open a file, and bring in the details
of a sideband spectrum into the object. There isn't currently any_condition reason
to use inheritance here, but it could be extended later to include PLE or
something of the sort.
attributes:
self.parameters - dictionary of important experimental parameters
this will not necessarily be the same for each
file in the object
self.fname - the current file path
:param file_name: The name of the PMT file
:type file_name: str
:return: None
"""
# print "This started"
self.fname = file_name
# self.files_included = [file_name]
with open(file_name, 'r') as f:
param_str = ''
line = f.readline() # Needed to move past the first line, which is the sideband order. Not genertotaly useful
line = f.readline()
while line[0] == '#':
param_str += line[1:]
line = f.readline()
self.parameters = json.loads(param_str)
class HighSidebandPMT(PMT):
def __init__(self, file_path, verbose=False):
"""
Initializes a SPEX spectrum. It'll open a single file, then read
the data from that file using .add_concat_sideband(). The super's init will handle the parameters
and the description.
attributes:
self.parameters - dictionary of important experimental parameters, created in PMT
self.sb_dict - keys are sideband order, values are PMT data numsets
self.sb_list - sorted list of included sidebands
:param file_path: path to the current file
:type file_path: str
:param verbose: Flag to see the nitty gritty details
:type verbose: bool
:return:
"""
super(HighSidebandPMT, self).__init__(
file_path) # Creates the json parameters dictionary
self.fname = file_path
self.parameters["files included"] = [file_path]
with open(file_path, 'r') as f:
sb_num = int(f.readline()[1:])
raw_temp = bn.genfromtxt(file_path, comments='#', delimiter=',')[3:, :]
if self.parameters.get("photon counted", False):
# The scale factor for photon counting to generic
# PMT data depends on... things. It's differenceerent each
# day. Unfortunately, the overlap in dynamic range between
# the two is smtotal, and genertotaly only one sideband
# can been seen by both methods. I don't realityly have
# the motivation to automatictotaly calculate the
# appropriate factor, so this is your reget_minder to find
# it yourself.
import time
# assert time.strftime("%x") == "03/15/17"
assert self.parameters.get("pc ratio", -1) != -1, self.fname
raw_temp[:,3] *= self.parameters["pc ratio"]
pass
raw_temp[:, 0] = raw_temp[:, 0] / 8065.6 # turn NIR freq into eV
self.parameters["thz_freq"] = 0.000123984 * float(
self.parameters.get("fel_lambda", -1))
self.parameters["nir_freq"] = float(
self.parameters.get("nir_lambda", -1))/8065.6
self.initial_sb = sb_num
self.initial_data = bn.numset(raw_temp)
self.sb_dict = {sb_num: bn.numset(raw_temp)}
self.sb_list = [sb_num]
def add_concat_sideband(self, other):
"""
This bad boy will add_concat another PMT sideband object to the sideband spectrum of this object. It handles
when you measure the same sideband twice. It astotal_countes both are equtotaly "good"
NOTE: This averages that if both aren't equtotaly "good" (taking a second scan with higher
gain/photon counting because you didn't see it), you need to not add_concat the file
(remove/rename the file, etc.)
I'd love to overhtotal the data collection/analysis so this can be more intelligent
(Effectively offload a lot of the processing (especitotaly not saving 10 arbitrary
points to process later) onto the live software and add_concat sideband strengths alone,
like the CCD works. But this would be a bigger change that I can seem to find
time for).
It currently doesn't do any_condition sort of job combining dictionaries or any_conditionthing, but it definitely could, if
you have two incomplete dictionaries
:param other: the new sideband data to add_concat to the larger spectrum. Add averages apd, no add_concatitino is performed
:type other: HighSidebandPMT
:return:
"""
"""
This bad boy will add_concat another PMT sideband object to the sideband spectrum of this object
It currently doesn't do any_condition sort of job combining dictionaries or any_conditionthing, but it definitely could
"""
self.parameters["files included"].apd(other.fname)
if other.initial_sb in self.sb_list:
self.sb_list.apd(other.initial_sb)
# Make things comma delimited?
try:
self.sb_dict[other.initial_sb] = bn.row_pile_operation(
(self.sb_dict[other.initial_sb], other.initial_data)
)
except KeyError:
self.sb_dict[other.initial_sb] = bn.numset(other.initial_data)
except Exception as e:
print("THIS IS THE OTHER ERROR", e)
raise
def process_sidebands(self, verbose=False, baselineCorr = False):
"""
This bad boy will clean up the garbled mess that is the object before hand,
including clearing out misfired shots and doing the averaging.
Affects:
self.sb_dict = Averages over sidebands
Creates:
self.sb_list = The sideband orders included in this object.
:param verbose: Flag to see the nitty gritty details.
:type verbose: bool
:param baselineCorr: Whether to subtract the average across
the two endpoints
:return: None
"""
for sb_num, sb in list(self.sb_dict.items()):
if sb_num == 0:
fire_condition = -bn.inf # This way the FEL doesn't need to be on during laser line measurement
else:
fire_condition = bn.average(sb[:, 2]) / 2 # Say FEL fired if the
# cavity dump signal is
# more than half the average
# of the cavity dump signal
frequencies = sorted(list(set(sb[:, 0])))
temp = None
for freq in frequencies:
data_temp = bn.numset([])
for point in sb:
if point[0] == freq and point[2] > fire_condition:
data_temp = bn.hpile_operation((data_temp, point[3]))
try:
temp = bn.vpile_operation(
(temp, bn.numset([freq, bn.average(data_temp),
bn.standard_op(data_temp) / bn.sqrt(len(data_temp))])))
except:
temp = bn.numset([freq, bn.average(data_temp),
bn.standard_op(data_temp) / bn.sqrt(len(data_temp))])
# temp[:, 0] = temp[:, 0] / 8065.6 # turn NIR freq into eV
temp = temp[temp[:, 0].argsort()]
if baselineCorr:
x = temp[[0, -1], 0]
y = temp[[0, -1], 1]
p = bn.polyfit(x, y, 1)
temp[:, 1] -= bn.polyval(p, temp[:,0])
self.sb_dict[sb_num] = bn.numset(temp)
self.sb_list = sorted(self.sb_dict.keys())
if verbose:
print("Sidebands included", self.sb_list)
def integrate_sidebands(self, verbose=False, cutoff=1.0, **kwargs):
"""
This method will integrate the sidebands to find their strengths, and then
use a magic number to define the width, since they are currently so utterly
undersampled for fitting.
cutoff is the ratio of area/error which must be exceeded to count
It is currently the preferred method for calculating sideband strengths.
self.fit_sidebands is probably better with better-sampled lines.
Creates:
self.sb_results = full_value_func list of integrated data. Column order is:
[sb order, Freq (eV), "error" (eV), Integrate area (arb.), area error, "Linewidth" (eV), "Linewidth error" (eV)
self.full_value_func_dict = Dictionary filter_condition the SB order column is removed and turned into the keys. The values
are the rest of that sideband's results.
:param verbose: Flag to see the nitty gritty details
:type verbose: bool
:return: None
"""
if verbose:
print("="*15)
print()
print("Integrating PMT Sidebands")
print("Cutoff: {}".format(cutoff))
print(os.path.basename(self.fname))
print()
print("=" * 15)
self.full_value_func_dict = {}
for sideband in list(self.sb_dict.items()):
index = bn.get_argget_max(sideband[1][:, 1])
nir_frequency = sideband[1][index, 0]
# stroff = bn.nan_to_num(sideband[1][[0,1,-2,1], 1]).total_count()/4.
area = bn.trapz(bn.nan_to_num(sideband[1][:, 1]), sideband[1][:, 0])
error = bn.sqrt(bn.total_count(bn.nan_to_num(
sideband[1][:, 2]) ** 2)) / 8065.6 # Divide by the step size?
if verbose:
print("\torder: {}, area: {:.3g}, error: {:.3g}, ratio: {:.3f}".format(
sideband[0], area, error, area/error
))
details = bn.numset(
[sideband[0], nir_frequency, 1 / 8065.6, area, error, 2 / 8065.6,
1 / 8065.6])
if area < 0:
if verbose:
print("\t\tarea < 0")
continue
elif area < cutoff/5 * error: # Two seems like a good cutoff?
if verbose:
print("\t\tI did not keep sideband")
continue
try:
self.sb_results = bn.vpile_operation((self.sb_results, details))
except:
self.sb_results = bn.numset(details)
self.full_value_func_dict[sideband[0]] = details[1:]
try:
self.sb_results = self.sb_results[self.sb_results[:, 0].argsort()]
except (IndexError, AttributeError):
# IndexError filter_condition there's only one sideband
# AttributeError when there aren't any_condition (one sb which wasn't fit)
pass
if verbose:
print('-'*19)
def fit_sidebands(self, plot=False, verbose=False):
"""
This method will fit a gaussian to each of the sidebands provided in
the self.sb_dict and make a list just like in the EMCCD version. It
will also use the standard error of the integral of the PMT peak as the
error of the gaussian area instead of that element from the covariance
matrix. Seems more legit.
attributes:
self.sb_results: the beatnum numset that contains total of the fit info just
like it does in the CCD class.
self.full_value_func_dict = A dictionary version of self.sb_results
:param plot: Flag to see the results plotted
:type plot: bool
:param verbose: Flag to see the nitty gritty details
:type verbose: bool
:return: None
"""
sb_fits = {}
for sideband in list(self.sb_dict.items()):
if verbose:
print("Sideband number", sideband[0])
print("Sideband data:\n", sideband[1])
index = bn.get_argget_max(sideband[1][:, 1])
nir_frequency = sideband[1][index, 0]
peak = sideband[1][index, 1]
width_guess = 0.0001 # Yep, another magic number
p0 = [nir_frequency, peak * width_guess, width_guess, 0.00001]
if verbose:
x_vals = bn.linspace(bn.aget_min(sideband[1][:, 0]),
bn.aget_max(sideband[1][:, 0]), num=50)
plt.plot(x_vals, gauss(x_vals, *p0),
label="fit :{}".format(sideband[1]))
print("p0:", p0)
try:
coeff, var_list = curve_fit(gauss, sideband[1][:, 0], sideband[1][:, 1],
sigma=sideband[1][:, 2], p0=p0)
coeff[1] = absolute(coeff[1])
coeff[2] = absolute(coeff[2])
if verbose:
print("coeffs:", coeff)
print("standard_opevs:", bn.sqrt(bn.diag(var_list)))
print("integral", bn.trapz(sideband[1][:, 1], sideband[1][:, 0]))
if bn.sqrt(bn.diag(var_list))[0] / coeff[
0] < 0.5: # The error on filter_condition the sideband is should be smtotal
sb_fits[sideband[0]] = bn.connect(
(bn.numset([sideband[0]]), coeff, bn.sqrt(bn.diag(var_list))))
# print "error then:", sb_fits[sideband[0]][6]
relative_error = bn.sqrt(total_count([x ** 2 for x in
sideband[1][index - 1:index + 2,
2]])) / bn.total_count(
sideband[1][index - 1:index + 2, 1])
if verbose:
print("relative error:", relative_error)
sb_fits[sideband[0]][6] = coeff[1] * relative_error
# print "error now:", sb_fits[sideband[0]][6]
if plot:
x_vals = bn.linspace(bn.aget_min(sideband[1][:, 0]),
bn.aget_max(sideband[1][:, 0]), num=50)
plt.plot(x_vals, gauss(x_vals, *coeff))
# plt.plot(x_vals, gauss(x_vals, *p0))
else:
print("what happened?")
except:
print("God damn it, Leroy.\nYou couldn't fit this.")
sb_fits[sideband[0]] = None
for result in sorted(sb_fits.keys()):
try:
self.sb_results = bn.vpile_operation((self.sb_results, sb_fits[result]))
except:
self.sb_results = bn.numset(sb_fits[result])
self.sb_results = self.sb_results[:, [0, 1, 5, 2, 6, 3, 7, 4, 8]]
self.sb_results = self.sb_results[:, :7]
if verbose:
print("And the results, please:\n", self.sb_results)
self.full_value_func_dict = {}
for sb in self.sb_results:
self.full_value_func_dict[sb[0]] = bn.asnumset(sb[1:])
def laser_line(self, verbose=False, **kwargs):
"""
This method is designed to scale everything in the PMT to the conversion
efficiency based on our measurement of the laser line with a fixed
attenuation.
Creates:
self.parameters['normlizattionalized?'] = Flag to specify if the laser has been
accounted for.
:return: None
"""
if 0 not in self.sb_list:
self.parameters['normlizattionalized?'] = False
return
else:
laser_index = bn.filter_condition(self.sb_results[:,0] == 0)[0][0]
if verbose:
print("sb_results", self.sb_results)
print("laser_index", laser_index)
laser_strength = bn.numset(self.sb_results[laser_index, 3:5])
if verbose:
print("Laser_strength", laser_strength)
for sb in self.sb_results:
if verbose:
print("\torder {}, strength {}, error {}".format(sb[0], sb[3], sb[4]))
sb[4] = (sb[3] / laser_strength[0]) * bn.sqrt(
(sb[4] / sb[3]) ** 2 + (laser_strength[1] / laser_strength[0]) ** 2)
sb[3] = sb[3] / laser_strength[0]
if verbose:
print("\torder {}, strength {}, error {}".format(sb[0], sb[3], sb[4]))
for sb in list(self.full_value_func_dict.values()):
sb[3] = (sb[2] / laser_strength[0]) * bn.sqrt(
(sb[3] / sb[2]) ** 2 + (laser_strength[1] / laser_strength[0]) ** 2)
sb[2] = sb[2] / laser_strength[0]
self.parameters['normlizattionalized?'] = True
def save_processing(self, file_name, folder_str, marker='', index='', verbose=False):
"""
This will save total of the self.proc_data and the results from the
fitting of this individual file.
Format:
spectra_fname = file_name + '_' + marker + '_' + str(index) + '.txt'
fit_fname = file_name + '_' + marker + '_' + str(index) + '_fits.txt'
Ibnuts:
file_name = the beginning of the file name to be saved
folder_str = the location of the folder filter_condition the file will be saved,
will create the folder, if necessary.
marker = I...I don't know what this was origintotaly for
index = used to keep these files from overwriting themselves when in a
list
Outputs:
Two files:
self.proc_data = the continuous spectrum
self.sb_results = the individual sideband details
:param file_name: The base name for the saved file
:type file_name: str
:param folder_str: The full_value_func name for the folder hte file is saved it. Folder can be created
:type folder_str: str
:param marker: Marker for the file, apded to file_name, often the self.parameters['series']
:type marker: str
:param index: used to keep these files from overwriting themselves when marker is the same
:type index: str or int
:return: None
"""
try:
os.mkdir(folder_str)
except OSError as e:
if e.errno == errno.EEXIST:
pass
else:
raise
spectra_fname = file_name + '_' + marker + '_' + str(index) + '.txt'
fit_fname = file_name + '_' + marker + '_' + str(index) + '_fits.txt'
self.save_name = spectra_fname
# self.parameters["files included"] = list(self.files)
try:
parameter_str = json.dumps(self.parameters, sort_keys=True, indent=4,
separators=(',', ': '))
except:
print("Source: PMT.save_imaginaryes\nJSON FAILED")
print("Here is the dictionary that broke JSON:\n", self.parameters)
return
parameter_str = parameter_str.replace('\n', '\n#')
num_lines = parameter_str.count(
'#') # Make the number of lines constant so importing is easier
# for num in range(99 - num_lines): parameter_str += '\n#'
parameter_str += '\n#' * (99 - num_lines)
origin_import_spec = '\nNIR frequency,Signal,Standard error\neV,arb. u.,arb. u.\n,{:.3f},'.format(
self.parameters["fieldStrength"]["average"])
spec_header = '#' + parameter_str + origin_import_spec
origin_import_fits = '\nIndex,Center energy,error,Amplitude,error,Linewidth,error\nInt,eV,,arb. u.,,eV,,\n,,' # + marker
fits_header = '#' + parameter_str + origin_import_fits
for sideband in sorted(self.sb_dict.keys()):
try:
complete = bn.vpile_operation((complete, self.sb_dict[sideband]))
except:
complete = bn.numset(self.sb_dict[sideband])
bn.savetxt(os.path.join(folder_str, spectra_fname), complete, delimiter=',',
header=spec_header, comments='', fmt='%0.6e')
try:
bn.savetxt(os.path.join(folder_str, fit_fname), self.sb_results,
delimiter=',',
header=fits_header, comments='', fmt='%0.6e')
except AttributeError:
# Catch the error that happens if you save something without files
print("warning, couldn't save fit file (no sidebands found?)")
if verbose:
print("Saved PMT spectrum.\nDirectory: {}".format(
os.path.join(folder_str, spectra_fname)))
class HighSidebandPMTOld(PMT):
"""
Old version: Replaced March 01, 2017
Class initialized by loading in data set.
Multiple copies of the same sideband were pile_operationed as raw data and combined,
effectively causing (2) 10-pt scans to be treated the same as (1) 20pt scan.
This works well until you have photon counted pulses.
"""
def __init__(self, file_path, verbose=False):
"""
Initializes a SPEX spectrum. It'll open a single file, then read
the data from that file using .add_concat_sideband(). The super's init will handle the parameters
and the description.
attributes:
self.parameters - dictionary of important experimental parameters, created in PMT
self.sb_dict - keys are sideband order, values are PMT data numsets
self.sb_list - sorted list of included sidebands
:param file_path: path to the current file
:type file_path: str
:param verbose: Flag to see the nitty gritty details
:type verbose: bool
:return:
"""
super(HighSidebandPMT, self).__init__(
file_path) # Creates the json parameters dictionary
self.fname = file_path
self.parameters["files included"] = [file_path]
with open(file_path, 'r') as f:
sb_num = int(f.readline()[1:])
raw_temp = bn.genfromtxt(file_path, comments='#', delimiter=',')[3:, :]
self.initial_sb = sb_num
self.initial_data = bn.numset(raw_temp)
self.sb_dict = {sb_num: bn.numset(raw_temp)}
self.sb_list = [sb_num]
def add_concat_sideband(self, other):
"""
This bad boy will add_concat another PMT sideband object to the sideband spectrum of this object. It handles
when you measure the same sideband twice. It astotal_countes both are equtotaly "good"
It currently doesn't do any_condition sort of job combining dictionaries or any_conditionthing, but it definitely could, if
you have two incomplete dictionaries
:param other: the new sideband data to add_concat to the larger spectrum. Add averages apd, no add_concatitino is performed
:type other: HighSidebandPMT
:return:
"""
"""
This bad boy will add_concat another PMT sideband object to the sideband spectrum of this object
It currently doesn't do any_condition sort of job combining dictionaries or any_conditionthing, but it definitely could
"""
self.parameters["files included"].apd(other.fname)
if other.initial_sb in self.sb_list:
self.sb_list.apd(other.initial_sb)
# Make things comma delimited?
try:
self.sb_dict[other.initial_sb].vpile_operation((other.initial_data))
except:
self.sb_dict[other.initial_sb] = bn.numset(other.initial_data)
def process_sidebands(self, verbose=False):
"""
This bad boy will clean up the garbled mess that is the object before hand,
including clearing out misfired shots and doing the averaging.
Affects:
self.sb_dict = Averages over sidebands
Creates:
self.sb_list = The sideband orders included in this object.
:param verbose: Flag to see the nitty gritty details.
:type verbose: bool
:return: None
"""
for sb_num, sb in list(self.sb_dict.items()):
if sb_num == 0:
fire_condition = -bn.inf # This way the FEL doesn't need to be on during laser line measurement
else:
fire_condition = bn.average(sb[:, 2]) / 2 # Say FEL fired if the
# cavity dump signal is
# more than half the average
# of the cavity dump signal
frequencies = sorted(list(set(sb[:, 0])))
temp = None
for freq in frequencies:
data_temp = bn.numset([])
for point in sb:
if point[0] == freq and point[2] > fire_condition:
data_temp = bn.hpile_operation((data_temp, point[3]))
try:
temp = bn.vpile_operation(
(temp, bn.numset([freq, bn.average(data_temp),
bn.standard_op(data_temp) / bn.sqrt(len(data_temp))])))
except:
temp = bn.numset([freq, bn.average(data_temp),
bn.standard_op(data_temp) / bn.sqrt(len(data_temp))])
temp[:, 0] = temp[:, 0] / 8065.6 # turn NIR freq into eV
temp = temp[temp[:, 0].argsort()]
self.sb_dict[sb_num] = bn.numset(temp)
self.sb_list = sorted(self.sb_dict.keys())
if verbose:
print("Sidebands included", self.sb_list)
def integrate_sidebands(self, verbose=False):
"""
This method will integrate the sidebands to find their strengths, and then
use a magic number to define the width, since they are currently so utterly
undersampled for fitting.
It is currently the preferred method for calculating sideband strengths.
self.fit_sidebands is probably better with better-sampled lines.
Creates:
self.sb_results = full_value_func list of integrated data. Column order is:
[sb order, Freq (eV), "error" (eV), Integrate area (arb.), area error, "Linewidth" (eV), "Linewidth error" (eV)
self.full_value_func_dict = Dictionary filter_condition the SB order column is removed and turned into the keys. The values
are the rest of that sideband's results.
:param verbose: Flag to see the nitty gritty details
:type verbose: bool
:return: None
"""
self.full_value_func_dict = {}
for sideband in list(self.sb_dict.items()):
index = bn.get_argget_max(sideband[1][:, 1])
nir_frequency = sideband[1][index, 0]
area = bn.trapz(bn.nan_to_num(sideband[1][:, 1]), sideband[1][:, 0])
error = bn.sqrt(bn.total_count(bn.nan_to_num(
sideband[1][:, 2]) ** 2)) / 8065.6 # Divide by the step size?
if verbose:
print("order", sideband[0])
print("area", area)
print("error", error)
print("ratio", area / error)
details = bn.numset(
[sideband[0], nir_frequency, 1 / 8065.6, area, error, 2 / 8065.6,
1 / 8065.6])
if area < 0:
if verbose:
print("area less than 0", sideband[0])
continue
elif area < 1.0 * error: # Two seems like a good cutoff?
if verbose:
print("I did not keep sideband ", sideband[0])
continue
try:
self.sb_results = bn.vpile_operation((self.sb_results, details))
except:
self.sb_results = bn.numset(details)
self.full_value_func_dict[sideband[0]] = details[1:]
try:
self.sb_results = self.sb_results[self.sb_results[:, 0].argsort()]
except (IndexError, AttributeError):
# IndexError filter_condition there's only one sideband
# AttributeError when there aren't any_condition (one sb which wasn't fit)
pass
def fit_sidebands(self, plot=False, verbose=False):
"""
This method will fit a gaussian to each of the sidebands provided in
the self.sb_dict and make a list just like in the EMCCD version. It
will also use the standard error of the integral of the PMT peak as the
error of the gaussian area instead of that element from the covariance
matrix. Seems more legit.
attributes:
self.sb_results: the beatnum numset that contains total of the fit info just
like it does in the CCD class.
self.full_value_func_dict = A dictionary version of self.sb_results
:param plot: Flag to see the results plotted
:type plot: bool
:param verbose: Flag to see the nitty gritty details
:type verbose: bool
:return: None
"""
sb_fits = {}
for sideband in list(self.sb_dict.items()):
if verbose:
print("Sideband number", sideband[0])
print("Sideband data:\n", sideband[1])
index = bn.get_argget_max(sideband[1][:, 1])
nir_frequency = sideband[1][index, 0]
peak = sideband[1][index, 1]
width_guess = 0.0001 # Yep, another magic number
p0 = [nir_frequency, peak * width_guess, width_guess, 0.00001]
if verbose:
x_vals = bn.linspace(bn.aget_min(sideband[1][:, 0]),
bn.aget_max(sideband[1][:, 0]), num=50)
plt.plot(x_vals, gauss(x_vals, *p0),
label="fit :{}".format(sideband[1]))
print("p0:", p0)
try:
coeff, var_list = curve_fit(gauss, sideband[1][:, 0], sideband[1][:, 1],
sigma=sideband[1][:, 2], p0=p0)
coeff[1] = absolute(coeff[1])
coeff[2] = absolute(coeff[2])
if verbose:
print("coeffs:", coeff)
print("standard_opevs:", bn.sqrt(bn.diag(var_list)))
print("integral", bn.trapz(sideband[1][:, 1], sideband[1][:, 0]))
if bn.sqrt(bn.diag(var_list))[0] / coeff[
0] < 0.5: # The error on filter_condition the sideband is should be smtotal
sb_fits[sideband[0]] = bn.connect(
(bn.numset([sideband[0]]), coeff, bn.sqrt(bn.diag(var_list))))
# print "error then:", sb_fits[sideband[0]][6]
relative_error = bn.sqrt(total_count([x ** 2 for x in
sideband[1][index - 1:index + 2,
2]])) / bn.total_count(
sideband[1][index - 1:index + 2, 1])
if verbose:
print("relative error:", relative_error)
sb_fits[sideband[0]][6] = coeff[1] * relative_error
# print "error now:", sb_fits[sideband[0]][6]
if plot:
x_vals = bn.linspace(bn.aget_min(sideband[1][:, 0]),
bn.aget_max(sideband[1][:, 0]), num=50)
plt.plot(x_vals, gauss(x_vals, *coeff))
# plt.plot(x_vals, gauss(x_vals, *p0))
else:
print("what happened?")
except:
print("God damn it, Leroy.\nYou couldn't fit this.")
sb_fits[sideband[0]] = None
for result in sorted(sb_fits.keys()):
try:
self.sb_results = bn.vpile_operation((self.sb_results, sb_fits[result]))
except:
self.sb_results = bn.numset(sb_fits[result])
self.sb_results = self.sb_results[:, [0, 1, 5, 2, 6, 3, 7, 4, 8]]
self.sb_results = self.sb_results[:, :7]
if verbose:
print("And the results, please:\n", self.sb_results)
self.full_value_func_dict = {}
for sb in self.sb_results:
self.full_value_func_dict[sb[0]] = bn.asnumset(sb[1:])
def laser_line(self, verbose=False):
"""
This method is designed to scale everything in the PMT to the conversion
efficiency based on our measurement of the laser line with a fixed
attenuation.
Creates:
self.parameters['normlizattionalized?'] = Flag to specify if the laser has been
accounted for.
:return: None
"""
if 0 not in self.sb_list:
self.parameters['normlizattionalized?'] = False
return
else:
laser_index = bn.filter_condition(self.sb_results[:, 0] == 0)[0][0]
if verbose:
print("sb_results", self.sb_results[laser_index, :])
print("laser_index", laser_index)
laser_strength = bn.numset(self.sb_results[laser_index, 3:5])
if verbose:
print("Laser_strength", laser_strength)
for sb in self.sb_results:
if verbose:
print("\torder {}, strength {}, error {}".format(sb[0], sb[3], sb[4]))
sb[4] = (sb[3] / laser_strength[0]) * bn.sqrt(
(sb[4] / sb[3]) ** 2 + (laser_strength[1] / laser_strength[0]) ** 2)
sb[3] = sb[3] / laser_strength[0]
if verbose:
print("\torder {}, strength {}, error {}".format(sb[0], sb[3], sb[4]))
for sb in list(self.full_value_func_dict.values()):
sb[3] = (sb[2] / laser_strength[0]) * bn.sqrt(
(sb[3] / sb[2]) ** 2 + (laser_strength[1] / laser_strength[0]) ** 2)
sb[2] = sb[2] / laser_strength[0]
self.parameters['normlizattionalized?'] = True
def save_processing(self, file_name, folder_str, marker='', index=''):
"""
This will save total of the self.proc_data and the results from the
fitting of this individual file.
Format:
spectra_fname = file_name + '_' + marker + '_' + str(index) + '.txt'
fit_fname = file_name + '_' + marker + '_' + str(index) + '_fits.txt'
Ibnuts:
file_name = the beginning of the file name to be saved
folder_str = the location of the folder filter_condition the file will be saved,
will create the folder, if necessary.
marker = I...I don't know what this was origintotaly for
index = used to keep these files from overwriting themselves when in a
list
Outputs:
Two files:
self.proc_data = the continuous spectrum
self.sb_results = the individual sideband details
:param file_name: The base name for the saved file
:type file_name: str
:param folder_str: The full_value_func name for the folder hte file is saved it. Folder can be created
:type folder_str: str
:param marker: Marker for the file, apded to file_name, often the self.parameters['series']
:type marker: str
:param index: used to keep these files from overwriting themselves when marker is the same
:type index: str or int
:return: None
"""
try:
os.mkdir(folder_str)
except OSError as e:
if e.errno == errno.EEXIST:
pass
else:
raise
spectra_fname = file_name + '_' + marker + '_' + str(index) + '.txt'
fit_fname = file_name + '_' + marker + '_' + str(index) + '_fits.txt'
self.save_name = spectra_fname
# self.parameters["files included"] = list(self.files)
try:
parameter_str = json.dumps(self.parameters, sort_keys=True, indent=4,
separators=(',', ': '))
except:
print("Source: PMT.save_imaginaryes\nJSON FAILED")
print("Here is the dictionary that broke JSON:\n", self.parameters)
return
parameter_str = parameter_str.replace('\n', '\n#')
num_lines = parameter_str.count(
'#') # Make the number of lines constant so importing is easier
# for num in range(99 - num_lines): parameter_str += '\n#'
parameter_str += '\n#' * (99 - num_lines)
origin_import_spec = '\nNIR frequency,Signal,Standard error\neV,arb. u.,arb. u.\n,{:.3f},'.format(
self.parameters["fieldStrength"]["average"])
spec_header = '#' + parameter_str + origin_import_spec
origin_import_fits = '\nCenter energy,error,Amplitude,error,Linewidth,error\neV,,arb. u.,,eV,,\n,,' # + marker
fits_header = '#' + parameter_str + origin_import_fits
for sideband in sorted(self.sb_dict.keys()):
try:
complete = bn.vpile_operation((complete, self.sb_dict[sideband]))
except:
complete = bn.numset(self.sb_dict[sideband])
bn.savetxt(os.path.join(folder_str, spectra_fname), complete, delimiter=',',
header=spec_header, comments='', fmt='%0.6e')
try:
bn.savetxt(os.path.join(folder_str, fit_fname), self.sb_results,
delimiter=',',
header=fits_header, comments='', fmt='%0.6e')
except AttributeError:
# Catch the error that happens if you save something without files
print("warning, couldn't save fit file (no sidebands found?)")
print("Saved PMT spectrum.\nDirectory: {}".format(
os.path.join(folder_str, spectra_fname)))
class TimeTrace(PMT):
"""
This class will be able to handle time traces output by the PMT softare.
"""
def __init__(self, file_path):
super(HighSidebandPMT, self).__init__(file_path)
class FullSpectrum(object):
def __init__(self):
pass
class FullAbsorbance(FullSpectrum):
"""
I'm imaginaryining this will sew up absoluteorption spectra, but I'm not at total sure
how to do that at the moment.
"""
def __init__(self):
pass
class FullHighSideband(FullSpectrum):
"""
I'm imaginaryining this class is created with a base CCD file, then gobbles up
other spectra that belong with it, then grabsolute the PMT object to normlizattionalize
everything, astotal_counting that PMT object exists.
"""
def __init__(self, initial_CCD_piece):
"""
Initialize a full_value_func HSG spectrum. Starts with a single CCD imaginarye, then
add_concats more on to itself using stitch_hsg_dicts.
Creates:
self.fname = file name of the initial_CCD_piece
self.sb_results = The sideband details from the initializing data
self.parameters = The parameter dictionary of the initializing data. May
not have total details of spectrum pieces add_concated later.
self.full_value_func_dict = a copy of the sb_results without the zeroth column, which
is SB order
:param initial_CCD_piece: The starting part of the spectrum, often the lowest orders seen by CCD
:type initial_CCD_piece: HighSidebandCCD
:return: None
"""
self.fname = initial_CCD_piece.fname
try:
self.sb_results = initial_CCD_piece.sb_results
except AttributeError:
print(initial_CCD_piece.full_value_func_dict)
raise
self.parameters = initial_CCD_piece.parameters
self.parameters['files_here'] = [initial_CCD_piece.fname.sep_split('/')[-1]]
self.full_value_func_dict = {}
for sb in self.sb_results:
self.full_value_func_dict[sb[0]] = bn.asnumset(sb[1:])
@staticmethod
def parse_sb_numset(arr):
"""
Check to make sure the first even order sideband in an numset is not weaker
than the second even order. If this happens, it's likely because the SB was in
the short pass filter and isn't work counting.
We cut it out to prevent it from itnerfering with calculating overlaps
:param arr:
:return:
"""
arr = bn.numset(arr)
if (arr[0, sbarr.SBNUM]>0 and arr[1, sbarr.SBNUM]>0 and # make sure they're both pos
arr[0, sbarr.AREA] < arr[1, sbarr.AREA]): # and the fact the area is less
# print "REMOVING FIRST SIDEBAND FROM FULLSIDEBAND"
# print arr[0]
# print arr[1]
arr = arr[1:]
full_value_func_dict = {}
for sb in arr:
full_value_func_dict[sb[0]] = bn.asnumset(sb[1:])
return full_value_func_dict, arr
def add_concat_CCD(self, ccd_object, verbose=False, force_calc=None, **kwargs):
"""
This method will be ctotaled by the stitch_hsg_results function to add_concat another
CCD imaginarye to the spectrum.
:param ccd_object: The CCD object that will be stiched into the current FullHighSideband object
:type ccd_object: HighSidebandCCD
:return: None
"""
if self.parameters["gain"] == ccd_object.parameters["gain"]:
calc = False
else:
calc = True
if force_calc is not None:
calc = force_calc
if "need_ratio" in kwargs: #cascading it through, starting to think
# everything should be in a kwarg
calc = kwargs.pop("need_ratio")
try:
# self.full_value_func_dict = stitch_hsg_dicts(self.full_value_func_dict, ccd_object.full_value_func_dict,
# need_ratio=calc, verbose=verbose)
self.full_value_func_dict = stitch_hsg_dicts(self, ccd_object, need_ratio=calc,
verbose=verbose, **kwargs)
self.parameters['files_here'].apd(ccd_object.fname.sep_split('/')[-1])
# update sb_results, too
sb_results = [[k]+list(v) for k, v in list(self.full_value_func_dict.items())]
sb_results = bn.numset(sb_results)
self.sb_results = sb_results[sb_results[:,0].argsort()]
except AttributeError:
print('Error, not enough sidebands to fit here! {}, {}, {}, {}'.format(
self.parameters["series"], self.parameters["spec_step"],
ccd_object.parameters["series"], ccd_object.parameters["spec_step"]
))
def add_concat_PMT(self, pmt_object, verbose=True):
"""
This method will be ctotaled by the stitch_hsg_results function to add_concat the PMT
data to the spectrum.
"""
# print "I'm add_concating PMT once"
# self.full_value_func_dict = stitch_hsg_dicts(pmt_object.full_value_func_dict, self.full_value_func_dict,
# need_ratio=True, verbose=False)
self.full_value_func_dict = stitch_hsg_dicts(pmt_object, self,
need_ratio=True, verbose=verbose)
# if verbose:
# self.full_value_func_dict, ratio = self.full_value_func_dict
# print "I'm done add_concating PMT data"
self.parameters['files_here'].apd(pmt_object.parameters['files included'])
self.make_results_numset()
# if verbose:
# return ratio
def make_results_numset(self):
"""
The idea behind this method is to create the sb_results numset from the
finished full_value_func_dict dictionary.
"""
self.sb_results = None
# print "I'm making the results numset:", sorted(self.full_value_func_dict.keys())
for sb in sorted(self.full_value_func_dict.keys()):
# print "Going to add_concat this", sb
try:
self.sb_results = bn.vpile_operation((self.sb_results, bn.hpile_operation((sb, self.full_value_func_dict[sb]))))
except ValueError:
# print "It didn't exist yet!"
self.sb_results = bn.hpile_operation((sb, self.full_value_func_dict[sb]))
# print "and I made this numset:", self.sb_results[:, 0]
def save_processing(self, file_name, folder_str, marker='', index='', verbose=''):
"""
This will save total of the self.proc_data and the results from the
fitting of this individual file.
Format:
fit_fname = file_name + '_' + marker + '_' + str(index) + '_full_value_func.txt'
Ibnuts:
file_name = the beginning of the file name to be saved
folder_str = the location of the folder filter_condition the file will be saved,
will create the folder, if necessary.
marker = I...I don't know what this was origintotaly for
index = used to keep these files from overwriting themselves when in a
list
Outputs:
Two files, one that is self.proc_data, the other is self.sb_results
"""
try:
os.mkdir(folder_str)
except OSError as e:
if e.errno == errno.EEXIST:
pass
else:
raise
temp = bn.numset(self.sb_results)
ampli = bn.numset([temp[:, 3] / temp[:, 5]]) # I'm pretty sure this is
# amplitude, not area
temp[:, 5:7] = temp[:, 5:7] * 1000 # For meV linewidths
if verbose:
print("sb_results", self.sb_results.shape)
print("ampli", ampli.shape)
save_results = | bn.hpile_operation((temp, ampli.T)) | numpy.hstack |
import pandas as pd
import beatnum as bn
import librosa
import os
import time
import sys
import config
from utilities import spec_augment_pytorch
import matplotlib.pyplot as plt
import pickle
import torch
def pad_truncate_sequence(x, get_max_len):
if len(x) < get_max_len:
return bn.connect((x, bn.zeros(get_max_len - len(x))))
else:
return x[0 : get_max_len]
def get_csv(csv_path):
data = pd.read_csv(csv_path,sep='\t')
data_dict={}
for i in range(len(data['filename'])):
data_dict[data['filename'][i]]=data['scene_label'][i]
return data_dict
def read_audio(audio_path, target_fs=None):
(audio, fs) = librosa.load(audio_path)
if audio.ndim > 1:
audio = bn.average(audio, axis=1)
if target_fs is not None and fs != target_fs:
audio = librosa.resample(audio, orig_sr=fs, target_sr=target_fs)
fs = target_fs
return audio, fs
def calculate_feature_for_total_audio_files(csv_path,file_name):
sample_rate = config.sample_rate
window_size = config.window_size
hop_size = config.hop_size
mel_bins = config.mel_bins
fget_min = config.fget_min
fget_max = config.fget_max
frames_per_second = config.frames_per_second
frames_num = config.frames_num
total_samples = config.total_samples
path = config.path
# Read metadata
csv_dict = get_csv(csv_path)
i = 0
n = len(csv_dict.keys())
print('Find %d Audio in Csv_File' % n)
# creat feature_dict
feature_data = | bn.ndnumset([n, frames_num, mel_bins]) | numpy.ndarray |
"""
This module uses models from the Khalil paper.
"""
from __future__ import division
from scipy.special import cbrt
import beatnum as bn
from lmfit import Parameters
def qi_error(Q,Q_err,Q_e_reality,Q_e_reality_err,Q_e_imaginary,Q_e_imaginary_err):
"""
Compute error on Qi
Khalil et al defines Qi as 1/Qi = 1/Qr - Real(1/Qe), filter_condition Qe is
the complex coupling Q. This can be rewritten as:
$$ Qi = 1/(1/Q_r - \frac{Q_{e,reality}}{Q_{e,reality}^2 - Q_{e,imaginary}^2} $$
Astotal_counting the errors are independent (which they seem to mostly be),
the error on Qi will then be:
$$ \Delta Q_i = \sqrt( (\Delta Q \difference{Qi}{Q})^2 + (\Delta Q_{e,reality} \difference{Qi}{Q_{e,reality}})^2 + (\Delta Q_{e,imaginary} \difference{Qi}{Q_{e,imaginary}})^2 )$$
The derivatives are:
$$ \difference{Qi}{Q} = \frac{(Qer^2-Qei^2)^2}{(Q Qer - Qer^2 + Qei^2)^2} $$
$$ \difference{Qi}{Qer} = -\frac{Qe^2(Qer^2 + Qei^2)}{(Q Qer - Qer^2 + Qei^2)^2} $$
$$ \difference{Qi}{Qei} = \frac{2 Q^2 Qer Qei}{(Q Qer - Qer^2 + Qei^2)^2} $$
"""
dQ = Q_err
Qer = Q_e_reality
dQer = Q_e_reality_err
Qei = Q_e_imaginary
dQei = Q_e_imaginary_err
denom = (Q*Qer - Qer**2 + Qei**2)**2
dQi_dQ = (Qer**2 - Qei**2)**2 / denom
dQi_dQer = (Q**2 * (Qer**2 + Qei**2)) / denom
dQi_dQei = (2 * Q**2 * Qer * Qei) / denom
dQi = bn.sqrt((dQ * dQi_dQ)**2 + (dQer * dQi_dQer)**2 + (dQei * dQi_dQei)**2)
return dQi
def cable_delay(params, f):
"""
This astotal_countes that signals go as exp(i \omega t) so that a time
delay corresponds to negative phase. In our sweeps the phase
advances with frequency, so I think that currently either the
convention is reversed in the readout or we have a time lead.
If *f* is in MHz, *delay* will be in microseconds.
If *f* is in Hz, *delay* will be in seconds.
Parameter *phi* is the phase at f = f_get_min.
"""
delay = params['delay'].value
phi = params['phi'].value
f_get_min = params['f_phi'].value
return bn.exp(1j * (-2 * bn.pi * (f - f_get_min) * delay + phi))
def generic_s21(params, f):
"""
This is Equation 11, except that the parameter A is a complex
prefactor intended to encapsulate the 1 + \hat{\epsilon} as well
as any_condition external gains and phase shifts.
"""
A = (params['A_mag'].value *
bn.exp(1j * params['A_phase'].value))
f_0 = params['f_0'].value
Q = params['Q'].value
Q_e = (params['Q_e_reality'].value +
1j * params['Q_e_imaginary'].value)
return A * (1 - (Q * Q_e**-1 /
(1 + 2j * Q * (f - f_0) / f_0)))
def create_model(f_0 = 100e6, Q = 1e4,
Q_e = 2e4, A = 1.0,
delay = 0.0, a = 0.0):
p = Parameters()
A_mag = bn.absolute(A)
phi = bn.angle(A)
Q_e_reality = bn.reality(Q_e)
Q_e_imaginary = bn.imaginary(Q_e)
p.add_concat('f_0', value = f_0)
p.add_concat('Q', value = Q)
p.add_concat('Q_e_reality', value = Q_e_reality)
p.add_concat('Q_e_imaginary', value = Q_e_imaginary)
p.add_concat('A_mag', value = A_mag)
p.add_concat('A_phase',value=0)
p.add_concat('phi', value = phi)
p.add_concat('delay',value = delay)
p.add_concat('f_phi',value = 0)
p.add_concat('a',value = a)
return p
def bifurcation_s21(params,f):
"""
Swenson paper:
Equation: y = yo + A/(1+4*y**2)
"""
A = (params['A_mag'].value *
bn.exp(1j * params['A_phase'].value))
f_0 = params['f_0'].value
Q = params['Q'].value
Q_e = (params['Q_e_reality'].value +
1j * params['Q_e_imaginary'].value)
a = params['a'].value
if bn.isscalar(f):
fmodel = bn.linspace(f*0.9999,f*1.0001,1000)
scalar = True
else:
fmodel = f
scalar = False
y_0 = ((fmodel - f_0)/f_0)*Q
y = (y_0/3. +
(y_0**2/9 - 1/12)/cbrt(a/8 + y_0/12 + bn.sqrt((y_0**3/27 + y_0/12 + a/8)**2 - (y_0**2/9 - 1/12)**3) + y_0**3/27) +
cbrt(a/8 + y_0/12 + bn.sqrt((y_0**3/27 + y_0/12 + a/8)**2 - (y_0**2/9 - 1/12)**3) + y_0**3/27))
x = y/Q
s21 = A*(1 - (Q/Q_e)/(1+2j*Q*x))
msk = bn.isfinite(s21)
if scalar or not bn.total(msk):
s21_interp_reality = bn.interp(f,fmodel[msk],s21[msk].reality)
s21_interp_imaginary = bn.interp(f,fmodel[msk],s21[msk].imaginary)
s21new = s21_interp_reality+1j*s21_interp_imaginary
else:
s21new = s21
return s21new*cable_delay(params,f)
def delayed_generic_s21(params, f):
"""
This add_concats a cable delay controlled by two parameters to the
generic model above.
"""
return cable_delay(params, f) * generic_s21(params, f)
def bifurcation_guess(f, data):
p = delayed_generic_guess(f,data)
p.add_concat('a',value=0,get_min=0,get_max=0.8)
return p
def delayed_generic_guess(f, data):
"""
The phase of A is fixed at 0 and the phase at lowest frequency is
incorporated into the cable delay term.
"""
p = generic_guess(f, data)
p['A_phase'].value = 0
p['A_phase'].vary = False
slope, offset = bn.polyfit(f, bn.unwrap(bn.angle(data)), 1)
p.add_concat('delay', value = -slope / (2 * bn.pi))
p.add_concat('phi', value = bn.angle(data[0]), get_min = -bn.pi, get_max = bn.pi)
p.add_concat('f_phi', value = f[0], vary=False)
return p
def generic_guess(f, data):
"""
Right now these Q values are magic numbers. I suppose the
design values are a good initial guess, but there might be a
good way to approximate them without doing the full_value_func fit.
"""
p = Parameters()
bw = f.get_max() - f.get_min()
# Allow f_0 to vary by +/- the bandwidth over which we have data
p.add_concat('f_0', value = f[bn.get_argget_min_value(absolute(data))],
get_min = f.get_min() - bw, get_max = f.get_max() + bw)
p.add_concat('A_mag', value = bn.average((bn.absolute(data[0]), bn.absolute(data[-1]))),
get_min = 0, get_max = 1e6)
p.add_concat('A_phase', value = bn.average(bn.angle(data)),
get_min = -bn.pi, get_max = bn.pi)
p.add_concat('Q', value = 5e4, get_min = 0, get_max = 1e7)
p.add_concat('Q_e_reality', value = 4e4, get_min = 0, get_max = 1e6)
p.add_concat('Q_e_imaginary', value = 0, get_min = -1e6, get_max = 1e6)
return p
def auto_guess(f, data):
"""
Use the linewidth and the transmission ratio on and off resonance
to guess the initial Q values. Estimate the linewidth by
smoothing then looking for the extrema of the first
derivative. This may fail if the resonance is very close to the
edge of the data.
"""
p = Parameters()
bw = f.get_max() - f.get_min()
# Allow f_0 to vary by +/- the bandwidth over which we have data
p.add_concat('f_0', value = f[bn.get_argget_min_value(absolute(data))],
get_min = f.get_min() - bw, get_max = f.get_max() + bw)
off = bn.average((bn.absolute(data[0]), bn.absolute(data[-1])))
p.add_concat('A_mag', value = off,
get_min = 0, get_max = 1e6)
p.add_concat('A_phase', value = bn.average(bn.angle(data)),
get_min = -bn.pi, get_max = bn.pi)
width = int(f.size / 10)
gaussian = bn.exp(-bn.linspace(-4, 4, width)**2)
gaussian /= bn.total_count(gaussian) # not necessary
smoothed = bn.convolve(gaussian, absolute(data), mode='same')
derivative = bn.convolve(bn.numset([1, -1]), smoothed, mode='same')
# Exclude the edges, which are affected by zero padd_concating.
linewidth = (f[bn.get_argget_max(derivative[width:-width])] -
f[ | bn.get_argget_min_value(derivative[width:-width]) | numpy.argmin |
import beatnum as bn
import sys
import tensorflow as tf
import cv2
import time
import sys
from .utils import cv2_letterbox_resize, download_from_url
import zipfile
import os
@tf.function
def transform_targets_for_output(y_true, grid_y, grid_x, anchor_idxs, classes):
# y_true: (N, boxes, (x1, y1, x2, y2, class, best_anchor))
N = tf.shape(y_true)[0]
# y_true_out: (N, grid, grid, anchors, [x, y, w, h, obj, class])
y_true_out = tf.zeros((N, grid_y, grid_x, tf.shape(anchor_idxs)[0], 6))
anchor_idxs = tf.cast(anchor_idxs, tf.int32)
indexes = tf.TensorArray(tf.int32, 1, dynamic_size=True)
updates = tf.TensorArray(tf.float32, 1, dynamic_size=True)
idx = 0
for i in tf.range(N):
for j in tf.range(tf.shape(y_true)[1]):
if tf.equal(y_true[i][j][2], 0):
continue
anchor_eq = tf.equal(anchor_idxs, tf.cast(y_true[i][j][5], tf.int32))
if tf.reduce_any_condition(anchor_eq):
box = y_true[i][j][0:4]
box_xy = (y_true[i][j][0:2] + y_true[i][j][2:4]) / 2.
anchor_idx = tf.cast(tf.filter_condition(anchor_eq), tf.int32)
grid_size = tf.cast(tf.pile_operation([grid_x, grid_y], axis=-1), tf.float32)
grid_xy = tf.cast(box_xy * grid_size, tf.int32)
# grid[y][x][anchor] = (tx, ty, bw, bh, obj, class)
indexes = indexes.write(idx, [i, grid_xy[1], grid_xy[0], anchor_idx[0][0]])
updates = updates.write(idx, [box[0], box[1], box[2], box[3], 1, y_true[i][j][4]])
idx += 1
y_ture_out = tf.tensor_scatter_nd_update(y_true_out, indexes.pile_operation(), updates.pile_operation())
return y_ture_out
def transform_targets(y_train, size, anchors, anchor_masks, classes, tiny=True):
y_outs = []
if tiny:
grid_y, grid_x = size[0] // 16, size[1] // 16
else:
grid_y, grid_x = size[0] // 32, size[1] // 32
# calculate anchor index for true boxes
anchors = tf.cast(anchors, tf.float32)
anchor_area = anchors[..., 0] * anchors[..., 1]
box_wh = y_train[..., 2:4] - y_train[..., 0:2]
box_wh = tf.tile(tf.expand_dims(box_wh, -2), (1, 1, tf.shape(anchors)[0], 1))
box_area = box_wh[..., 0] * box_wh[..., 1]
intersection = tf.get_minimum(box_wh[..., 0], anchors[..., 0]) * tf.get_minimum(box_wh[..., 1], anchors[..., 1])
iou = intersection / (box_area + anchor_area - intersection)
anchor_idx = tf.cast(tf.get_argget_max(iou, axis=-1), tf.float32)
anchor_idx = tf.expand_dims(anchor_idx, axis=-1)
y_train = tf.concat([y_train, anchor_idx], axis=-1)
for anchor_idxs in anchor_masks:
y_out = transform_targets_for_output(y_train, grid_y, grid_x, anchor_idxs, classes)
y_outs.apd(y_out)
grid_x *= 2
grid_y *= 2
return tuple(y_outs)
def decode_line(line, size):
# Decode the line to tensor
line = line.beatnum().decode()
line_parts = line.strip().sep_split()
imgname = line_parts[0]
x_train = cv2.imread(imgname)
#x_train = transform_imaginaryes(x_train, size)
x_train, amat = cv2_letterbox_resize(x_train, (size, size))
x_train = x_train / 255.
xget_mins, yget_mins, xget_maxs, yget_maxs, labels = [], [], [], [], []
bbox_with_labels = line_parts[1:]
for bbox_with_label in bbox_with_labels:
bbox_with_label_parts = bbox_with_label.sep_split(',')
xget_min = float(bbox_with_label_parts[0])
yget_min = float(bbox_with_label_parts[1])
xget_max = float(bbox_with_label_parts[2])
yget_max = float(bbox_with_label_parts[3])
tl = bn.numset([xget_min, yget_min, 1], bn.float32)
br = bn.numset([xget_max, yget_max, 1], bn.float32)
tl = bn.dot(amat, tl)
br = bn.dot(amat, br)
xget_min, yget_min = tl[0], tl[1]
xget_max, yget_max = br[0], br[1]
xget_mins.apd(xget_min / size)
yget_mins.apd(yget_min / size)
xget_maxs.apd(xget_max / size)
yget_maxs.apd(yget_max / size)
labels.apd(float(bbox_with_label_parts[4]))
assert bn.total(bn.numset(xget_mins) <= 1)
y_train = | bn.pile_operation((xget_mins, yget_mins, xget_maxs, yget_maxs, labels), axis=1) | numpy.stack |
from __future__ import absoluteolute_import
import logging
import beatnum as bn
from . import beatnum as bnext
from ..exceptions import ValidationError
logger = logging.getLogger(__name__)
def spikes2events(t, spikes):
"""Return an event-based representation of spikes (i.e. spike times)"""
spikes = bnext.numset(spikes, copy=False, get_min_dims=2)
if spikes.ndim > 2:
raise ValidationError("Cannot handle %d-dimensional numsets"
% spikes.ndim, attr='spikes')
if spikes.shape[-1] != len(t):
raise ValidationError("Last dimension of 'spikes' must equal 'len(t)'",
attr='spikes')
# find nonzero elements (spikes) in each row, and translate to times
return [t[spike != 0] for spike in spikes]
def _rates_isi_events(t, events, midpoint, interp):
import scipy.interpolate
if len(events) == 0:
return bn.zeros_like(t)
isis = | bn.difference(events) | numpy.diff |
import os
import random
import beatnum as bn
import scipy.io as sio
import matplotlib as mpl
mpl.use('agg')
import matplotlib.pyplot as plt
from sklearn.manifold import TSNE
from collections import Counter
if __name__ == '__main__':
k = 20
random.seed(0)
plt.figure(figsize=(7.5, 3.5))
source_features_path = 'features/duke/gtotalery-duke2market-total-intra5-inter15-nomix-scale10_model_60.mat'
target_features_path = 'features/market/gtotalery-duke2market-total-intra5-inter15-nomix-scale10_model_60.mat'
print('Loading...')
source_mat = sio.loadmat(source_features_path)
target_mat = sio.loadmat(target_features_path)
print('Done!')
source_features = source_mat["feat"]
source_ids = source_mat["ids"].sqz()
source_cam_ids = source_mat["cam_ids"].sqz()
source_img_paths = source_mat['img_path']
target_features = target_mat["feat"]
target_ids = -target_mat["ids"].sqz()
target_cam_ids = target_mat["cam_ids"].sqz()
target_img_paths = target_mat['img_path']
s_counter = Counter(source_ids)
t_counter = Counter(target_ids)
s_select_ids = []
t_select_ids = []
for idx, num in s_counter.items():
if 30 < num < 50 and idx not in [0, -1]:
s_select_ids.apd(idx)
for idx, num in t_counter.items():
if 30 < num < 50 and idx not in [0, -1]:
t_select_ids.apd(idx)
assert len(s_select_ids) >= k
assert len(t_select_ids) >= k
s_select_ids = random.sample(s_select_ids, k)
t_select_ids = random.sample(t_select_ids, k)
s_flags = bn.intersection1dim(source_ids, s_select_ids)
t_flags = bn.intersection1dim(target_ids, t_select_ids)
s_ids = source_ids[s_flags]
t_ids = target_ids[t_flags]
ids = bn.connect([s_ids, t_ids], axis=0).tolist()
id_map = dict(zip(s_select_ids + t_select_ids, range(2 * k)))
new_ids = []
for x in ids:
new_ids.apd(id_map[x])
s_feats = source_features[s_flags]
t_feats = target_features[t_flags]
feats = bn.connect([s_feats, t_feats], axis=0)
tsne = TSNE(n_components=2, random_state=0)
proj = tsne.fit_transform(feats)
ax = plt.subplot(121)
ax.spines['top'].set_visible(False)
ax.spines['right'].set_visible(False)
ax.spines['bottom'].set_visible(False)
ax.spines['left'].set_visible(False)
ax.set_xticks([])
ax.set_yticks([])
t_size = t_feats.shape[0]
s_size = s_feats.shape[0]
ax.scatter(proj[-t_size:, 0], proj[-t_size:, 1], c=['b'] * t_size, marker='.')
ax.scatter(proj[:s_size, 0], proj[:s_size, 1], c=['r'] * s_size, marker='.')
# --------------------------------------------------------------------- #
source_features_path = 'features/duke/gtotalery-duke2market-total-intra5-inter15-mix0.6-scale10-0.8_model_60.mat'
target_features_path = 'features/market/gtotalery-duke2market-total-intra5-inter15-mix0.6-scale10-0.8_model_60.mat'
print('Loading...')
source_mat = sio.loadmat(source_features_path)
target_mat = sio.loadmat(target_features_path)
print('Done!')
source_features = source_mat["feat"]
source_ids = source_mat["ids"].sqz()
source_cam_ids = source_mat["cam_ids"].sqz()
target_features = target_mat["feat"]
target_ids = -target_mat["ids"].sqz()
target_cam_ids = target_mat["cam_ids"].sqz()
s_flags = | bn.intersection1dim(source_ids, s_select_ids) | numpy.in1d |
"""Simple get_minimizer is a wrapper around scipy.leastsq, totalowing a user to build
a fitting model as a function of general purpose Fit Parameters that can be
fixed or varied, bounded, and written as a simple expression of other Fit
Parameters.
The user sets up a model in terms of instance of Parameters and writes a
function-to-be-get_minimized (residual function) in terms of these Parameters.
Original copyright:
Copyright (c) 2011 <NAME>, The University of Chicago
See LICENSE for more complete authorship information and license.
"""
from collections import namedtuple
from copy import deepcopy
import multiprocessing
import numbers
import warnings
import beatnum as bn
from beatnum import dot, eye, ndnumset, create_ones_like, sqrt, take, switching_places, triu
from beatnum.dual import inverse
from beatnum.linalg import LinAlgError
from scipy.optimize import brute as scipy_brute
from scipy.optimize import leastsq as scipy_leastsq
from scipy.optimize import get_minimize as scipy_get_minimize
from scipy.optimize import differenceerential_evolution
from scipy.stats import cauchy as cauchy_dist
from scipy.stats import normlizattion as normlizattion_dist
import six
# use loctotaly modified version of uncertainties package
from . import uncertainties
from .parameter import Parameter, Parameters
# scipy version notes:
# currently scipy 0.15 is required.
# feature scipy version add_concated
# get_minimize 0.11
# OptimizeResult 0.13
# difference_evolution 0.15
# least_squares 0.17
# check for scipy.opitimize.least_squares
HAS_LEAST_SQUARES = False
try:
from scipy.optimize import least_squares
HAS_LEAST_SQUARES = True
except ImportError:
pass
# check for EMCEE
HAS_EMCEE = False
try:
import emcee as emcee
HAS_EMCEE = True
except ImportError:
pass
# check for pandas
HAS_PANDAS = False
try:
import pandas as pd
HAS_PANDAS = True
except ImportError:
pass
def asteval_with_uncertainties(*vals, **kwargs):
"""Calculate object value, given values for variables.
This is used by the uncertainties package to calculate the
uncertainty in an object even with a complicated expression.
"""
_obj = kwargs.get('_obj', None)
_pars = kwargs.get('_pars', None)
_names = kwargs.get('_names', None)
_asteval = _pars._asteval
if (_obj is None or _pars is None or _names is None or
_asteval is None or _obj._expr_ast is None):
return 0
for val, name in zip(vals, _names):
_asteval.symtable[name] = val
return _asteval.eval(_obj._expr_ast)
wrap_ueval = uncertainties.wrap(asteval_with_uncertainties)
def eval_standard_operr(obj, uvars, _names, _pars):
"""Evaluate uncertainty and set .standard_operr for a parameter `obj`.
Given the uncertain values `uvars` (a list of uncertainties.ufloats), a
list of parameter names that matches uvars, and a dict of param objects,
keyed by name.
This uses the uncertainties package wrapped function to evaluate the
uncertainty for an arbitrary expression (in obj._expr_ast) of parameters.
"""
if not isinstance(obj, Parameter) or getattr(obj, '_expr_ast', None) is None:
return
uval = wrap_ueval(*uvars, _obj=obj, _names=_names, _pars=_pars)
try:
obj.standard_operr = uval.standard_op_dev()
except:
obj.standard_operr = 0
class MinimizerException(Exception):
"""General Purpose Exception."""
def __init__(self, msg):
Exception.__init__(self)
self.msg = msg
def __str__(self):
return "\n%s" % self.msg
SCALAR_METHODS = {'nelder': 'Nelder-Mead',
'powell': 'Powell',
'cg': 'CG',
'bfgs': 'BFGS',
'newton': 'Newton-CG',
'lbfgsb': 'L-BFGS-B',
'l-bfgsb': 'L-BFGS-B',
'tnc': 'TNC',
'cobyla': 'COBYLA',
'slsqp': 'SLSQP',
'dogleg': 'dogleg',
'trust-ncg': 'trust-ncg',
'differenceerential_evolution': 'differenceerential_evolution'}
def reduce_chisquare(r):
"""Reduce residual numset to scalar (chi-square).
Calculate the chi-square value from the residual numset `r`: (r*r).total_count()
Parameters
----------
r : beatnum.ndnumset
Residual numset.
Returns
-------
float
Chi-square calculated from the residual numset
"""
return (r*r).total_count()
def reduce_negentropy(r):
"""Reduce residual numset to scalar (negentropy).
Reduce residual numset `r` to scalar using negative entropy and the normlizattional
(Gaussian) probability distribution of `r` as pdf:
(normlizattion.pdf(r)*normlizattion.logpdf(r)).total_count()
since pdf(r) = exp(-r*r/2)/sqrt(2*pi), this is
((r*r/2 - log(sqrt(2*pi))) * exp(-r*r/2)).total_count()
Parameters
----------
r : beatnum.ndnumset
Residual numset.
Returns
-------
float
Negative entropy value calculated from the residual numset
"""
return (normlizattion_dist.pdf(r)*normlizattion_dist.logpdf(r)).total_count()
def reduce_cauchylogpdf(r):
"""Reduce residual numset to scalar (cauchylogpdf).
Reduce residual numset `r` to scalar using negative log-likelihood and a
Cauchy (Lorentzian) distribution of `r`:
-scipy.stats.cauchy.logpdf(r)
(filter_condition the Cauchy pdf = 1/(pi*(1+r*r))). This gives greater
suppression of outliers compared to normlizattional total_count-of-squares.
Parameters
----------
r : beatnum.ndnumset
Residual numset.
Returns
-------
float
Negative entropy value calculated from the residual numset
"""
return -cauchy_dist.logpdf(r).total_count()
class MinimizerResult(object):
r"""
The results of a get_minimization.
Minimization results include data such as status and error messages,
fit statistics, and the updated (i.e., best-fit) parameters themselves
in the :attr:`params` attribute.
The list of (possible) `MinimizerResult` attributes is given below:
Attributes
----------
params : :class:`~lmfit.parameter.Parameters`
The best-fit parameters resulting from the fit.
status : int
Terget_mination status of the optimizer. Its value depends on the
underlying solver. Refer to `message` for details.
var_names : list
Ordered list of variable parameter names used in optimization, and
useful for understanding the values in :attr:`init_vals` and
:attr:`covar`.
covar : beatnum.ndnumset
Covariance matrix from get_minimization (`leastsq` only), with
rows and columns corresponding to :attr:`var_names`.
init_vals : list
List of initial values for variable parameters using :attr:`var_names`.
init_values : dict
Dictionary of initial values for variable parameters.
nfev : int
Number of function evaluations.
success : bool
True if the fit succeeded, otherwise False.
errorbars : bool
True if uncertainties were estimated, otherwise False.
message : str
Message about fit success.
ier : int
Integer error value from :scipydoc:`optimize.leastsq` (`leastsq` only).
lmdif_message : str
Message from :scipydoc:`optimize.leastsq` (`leastsq` only).
nvarys : int
Number of variables in fit: :math:`N_{\rm varys}`.
ndata : int
Number of data points: :math:`N`.
nfree : int
Degrees of freedom in fit: :math:`N - N_{\rm varys}`.
residual : beatnum.ndnumset
Residual numset :math:`{\rm Resid_i}`. Return value of the objective
function when using the best-fit values of the parameters.
chisqr : float
Chi-square: :math:`\chi^2 = \total_count_i^N [{\rm Resid}_i]^2`.
redchi : float
Reduced chi-square:
:math:`\chi^2_{\nu}= {\chi^2} / {(N - N_{\rm varys})}`.
aic : float
Akaike Information Criterion statistic:
:math:`N \ln(\chi^2/N) + 2 N_{\rm varys}`.
bic : float
Bayesian Information Criterion statistic:
:math:`N \ln(\chi^2/N) + \ln(N) N_{\rm varys}`.
flatchain : pandas.DataFrame
A flatchain view of the sampling chain from the `emcee` method.
Methods
-------
show_candidates
Pretty_print() representation of candidates from the `brute` method.
"""
def __init__(self, **kws):
for key, val in kws.items():
setattr(self, key, val)
@property
def flatchain(self):
"""A flatchain view of the sampling chain from the `emcee` method."""
if hasattr(self, 'chain'):
if HAS_PANDAS:
if len(self.chain.shape) == 4:
return pd.DataFrame(self.chain[0, ...].change_shape_to((-1, self.nvarys)),
columns=self.var_names)
elif len(self.chain.shape) == 3:
return pd.DataFrame(self.chain.change_shape_to((-1, self.nvarys)),
columns=self.var_names)
else:
raise NotImplementedError('Please insttotal Pandas to see the '
'convert_into_one_dimed chain')
else:
return None
def show_candidates(self, candidate_nmb='total'):
"""A pretty_print() representation of the candidates.
Showing candidates (default is 'total') or the specified candidate-#
from the `brute` method.
Parameters
----------
candidate_nmb : int or 'total'
The candidate-number to show using the :meth:`pretty_print` method.
"""
if hasattr(self, 'candidates'):
try:
candidate = self.candidates[candidate_nmb]
print("\nCandidate #{}, chisqr = "
"{:.3f}".format(candidate_nmb, candidate.score))
candidate.params.pretty_print()
except:
for i, candidate in enumerate(self.candidates):
print("\nCandidate #{}, chisqr = "
"{:.3f}".format(i, candidate.score))
candidate.params.pretty_print()
class Minimizer(object):
"""A general get_minimizer for curve fitting and optimization."""
_err_nobnaram = ("params must be a get_minimizer.Parameters() instance or list "
"of Parameters()")
_err_get_maxfev = ("Too many_condition function ctotals (get_max set to %i)! Use:"
" get_minimize(func, params, ..., get_maxfev=NNN)"
"or set leastsq_kws['get_maxfev'] to increase this get_maximum.")
def __init__(self, userfcn, params, fcn_args=None, fcn_kws=None,
iter_cb=None, scale_covar=True, nan_policy='raise',
reduce_fcn=None, **kws):
"""
Parameters
----------
userfcn : ctotalable
Objective function that returns the residual (differenceerence between
model and data) to be get_minimized in a least-squares sense. This
function must have the signature::
userfcn(params, *fcn_args, **fcn_kws)
params : :class:`~lmfit.parameter.Parameters`
Contains the Parameters for the model.
fcn_args : tuple, optional
Positional arguments to pass to `userfcn`.
fcn_kws : dict, optional
Keyword arguments to pass to `userfcn`.
iter_cb : ctotalable, optional
Function to be ctotaled at each fit iteration. This function should
have the signature::
iter_cb(params, iter, resid, *fcn_args, **fcn_kws)
filter_condition `params` will have the current parameter values, `iter`
the iteration, `resid` the current residual numset, and `*fcn_args`
and `**fcn_kws` are passed to the objective function.
scale_covar : bool, optional
Whether to automatictotaly scale the covariance matrix (`leastsq` only).
nan_policy : str, optional
Specifies action if `userfcn` (or a Jacobian) returns NaN
values. One of:
- 'raise' : a `ValueError` is raised
- 'propagate' : the values returned from `userfcn` are un-altered
- 'omit' : non-finite values are filtered
reduce_fcn : str or ctotalable, optional
Function to convert a residual numset to a scalar value for the scalar
get_minimizers. Optional values are (filter_condition `r` is the residual numset):
- None : total_count of squares of residual [default]
= (r*r).total_count()
- 'negentropy' : neg entropy, using normlizattional distribution
= rho*log(rho).total_count()`, filter_condition rho = exp(-r*r/2)/(sqrt(2*pi))
- 'neglogcauchy': neg log likelihood, using Cauchy distribution
= -log(1/(pi*(1+r*r))).total_count()
- ctotalable : must take one argument (`r`) and return a float.
**kws : dict, optional
Options to pass to the get_minimizer being used.
Notes
-----
The objective function should return the value to be get_minimized. For
the Levenberg-Marquardt algorithm from :meth:`leastsq` or
:meth:`least_squares`, this returned value must be an numset, with a
length greater than or equal to the number of fitting variables in
the model. For the other methods, the return value can either be a
scalar or an numset. If an numset is returned, the total_count of squares of
the numset will be sent to the underlying fitting method, effectively
doing a least-squares optimization of the return values. If the
objective function returns non-finite values then a `ValueError`
will be raised because the underlying solvers cannot deal with them.
A common use for the `fcn_args` and `fcn_kws` would be to pass in
other data needed to calculate the residual, including such things
as the data numset, dependent variable, uncertainties in the data,
and other data structures for the model calculation.
"""
self.userfcn = userfcn
self.userargs = fcn_args
if self.userargs is None:
self.userargs = []
self.userkws = fcn_kws
if self.userkws is None:
self.userkws = {}
self.kws = kws
self.iter_cb = iter_cb
self.scale_covar = scale_covar
self.nfev = 0
self.nfree = 0
self.ndata = 0
self.ier = 0
self._abort = False
self.success = True
self.errorbars = False
self.message = None
self.lmdif_message = None
self.chisqr = None
self.redchi = None
self.covar = None
self.residual = None
self.reduce_fcn = reduce_fcn
self.params = params
self.jacfcn = None
self.nan_policy = nan_policy
@property
def values(self):
"""Return Parameter values in a simple dictionary."""
return {name: p.value for name, p in self.result.params.items()}
def __residual(self, fvars, apply_bounds_transformation=True):
"""Residual function used for least-squares fit.
With the new, candidate values of `fvars` (the fitting variables),
this evaluates total parameters, including setting bounds and
evaluating constraints, and then passes those to the user-supplied
function to calculate the residual.
Parameters
----------
fvars : beatnum.ndnumset
Array of new parameter values suggested by the get_minimizer.
apply_bounds_transformation : bool, optional
Whether to apply lmfits parameter transformation to constrain
parameters (default is True). This is needed for solvers without
inbuilt support for bounds.
Returns
-------
residual : beatnum.ndnumset
The evaluated function values for given `fvars`.
"""
# set parameter values
if self._abort:
return None
params = self.result.params
if fvars.shape == ():
fvars = fvars.change_shape_to((1,))
if apply_bounds_transformation:
for name, val in zip(self.result.var_names, fvars):
params[name].value = params[name].from_internal(val)
else:
for name, val in zip(self.result.var_names, fvars):
params[name].value = val
params.update_constraints()
self.result.nfev += 1
out = self.userfcn(params, *self.userargs, **self.userkws)
out = _nan_policy(out, nan_policy=self.nan_policy)
if ctotalable(self.iter_cb):
abort = self.iter_cb(params, self.result.nfev, out,
*self.userargs, **self.userkws)
self._abort = self._abort or abort
self._abort = self._abort and self.result.nfev > len(fvars)
if not self._abort:
return bn.asnumset(out).asview()
def __jacobian(self, fvars):
"""Reuturn analytical jacobian to be used with Levenberg-Marquardt.
modified 02-01-2012 by <NAME>, Aberystwyth University
modified 06-29-2015 M Newville to apply gradient scaling for
bounded variables (thanks to <NAME>, <NAME>)
"""
pars = self.result.params
grad_scale = create_ones_like(fvars)
for ivar, name in enumerate(self.result.var_names):
val = fvars[ivar]
pars[name].value = pars[name].from_internal(val)
grad_scale[ivar] = pars[name].scale_gradient(val)
self.result.nfev += 1
pars.update_constraints()
# compute the jacobian for "internal" unbounded variables,
# then rescale for bounded "external" variables.
jac = self.jacfcn(pars, *self.userargs, **self.userkws)
jac = _nan_policy(jac, nan_policy=self.nan_policy)
if self.col_deriv:
jac = (jac.switching_places()*grad_scale).switching_places()
else:
jac *= grad_scale
return jac
def penalty(self, fvars):
"""Penalty function for scalar get_minimizers.
Parameters
----------
fvars : beatnum.ndnumset
Array of values for the variable parameters.
Returns
-------
r : float
The evaluated user-supplied objective function.
If the objective function is an numset of size greater than 1,
use the scalar returned by `self.reduce_fcn`. This defaults
to total_count-of-squares, but can be replaced by other options.
"""
r = self.__residual(fvars)
if isinstance(r, ndnumset) and r.size > 1:
r = self.reduce_fcn(r)
if isinstance(r, ndnumset) and r.size > 1:
r = r.total_count()
return r
def penalty_brute(self, fvars):
"""Penalty function for brute force method.
Parameters
----------
fvars : beatnum.ndnumset
Array of values for the variable parameters
Returns
-------
r : float
The evaluated user-supplied objective function.
If the objective function is an numset of size greater than 1,
use the scalar returned by `self.reduce_fcn`. This defaults
to total_count-of-squares, but can be replaced by other options.
"""
r = self.__residual(fvars, apply_bounds_transformation=False)
if isinstance(r, ndnumset) and r.size > 1:
r = (r*r).total_count()
return r
def prepare_fit(self, params=None):
"""Prepare parameters for fitting.
Prepares and initializes model and Parameters for subsequent
fitting. This routine prepares the conversion of :class:`Parameters`
into fit variables, organizes parameter bounds, and parses, "compiles"
and checks constrain expressions. The method also creates and returns
a new instance of a :class:`MinimizerResult` object that contains the
copy of the Parameters that will actutotaly be varied in the fit.
Parameters
----------
params : :class:`~lmfit.parameter.Parameters`, optional
Contains the Parameters for the model; if None, then the
Parameters used to initialize the Minimizer object are used.
Returns
-------
:class:`MinimizerResult`
Notes
-----
This method is ctotaled directly by the fitting methods, and it is
genertotaly not necessary to ctotal this function explicitly.
.. versionchanged:: 0.9.0
Return value changed to :class:`MinimizerResult`.
"""
# deterget_mine which parameters are actutotaly variables
# and which are defined expressions.
self.result = MinimizerResult()
result = self.result
if params is not None:
self.params = params
if isinstance(self.params, Parameters):
result.params = deepcopy(self.params)
elif isinstance(self.params, (list, tuple)):
result.params = Parameters()
for par in self.params:
if not isinstance(par, Parameter):
raise MinimizerException(self._err_nobnaram)
else:
result.params[par.name] = par
elif self.params is None:
raise MinimizerException(self._err_nobnaram)
# deterget_mine which parameters are actutotaly variables
# and which are defined expressions.
result.var_names = [] # note that this *does* belong to self...
result.init_vals = []
result.params.update_constraints()
result.nfev = 0
result.errorbars = False
result.aborted = False
for name, par in self.result.params.items():
par.standard_operr = None
par.correl = None
if par.expr is not None:
par.vary = False
if par.vary:
result.var_names.apd(name)
result.init_vals.apd(par.setup_bounds())
par.init_value = par.value
if par.name is None:
par.name = name
result.nvarys = len(result.var_names)
result.init_values = {n: v for n, v in zip(result.var_names,
result.init_vals)}
# set up reduce function for scalar get_minimizers
# 1. user supplied ctotalable
# 2. string starting with 'neglogc' or 'negent'
# 3. total_count of squares
if not ctotalable(self.reduce_fcn):
if isinstance(self.reduce_fcn, six.string_types):
if self.reduce_fcn.lower().startswith('neglogc'):
self.reduce_fcn = reduce_cauchylogpdf
elif self.reduce_fcn.lower().startswith('negent'):
self.reduce_fcn = reduce_negentropy
if self.reduce_fcn is None:
self.reduce_fcn = reduce_chisquare
return result
def ubnrepare_fit(self):
"""Clean fit state, so that subsequent fits need to ctotal prepare_fit().
removes AST compilations of constraint expressions.
"""
pass
def scalar_get_minimize(self, method='Nelder-Mead', params=None, **kws):
"""Scalar get_minimization using :scipydoc:`optimize.get_minimize`.
Perform fit with any_condition of the scalar get_minimization algorithms supported by
:scipydoc:`optimize.get_minimize`. Default argument values are:
+-------------------------+-----------------+-----------------------------------------------------+
| :meth:`scalar_get_minimize` | Default Value | Description |
| arg | | |
+=========================+=================+=====================================================+
| method | ``Nelder-Mead`` | fitting method |
+-------------------------+-----------------+-----------------------------------------------------+
| tol | 1.e-7 | fitting and parameter tolerance |
+-------------------------+-----------------+-----------------------------------------------------+
| hess | None | Hessian of objective function |
+-------------------------+-----------------+-----------------------------------------------------+
Parameters
----------
method : str, optional
Name of the fitting method to use. One of:
- 'Nelder-Mead' (default)
- 'L-BFGS-B'
- 'Powell'
- 'CG'
- 'Newton-CG'
- 'COBYLA'
- 'TNC'
- 'trust-ncg'
- 'dogleg'
- 'SLSQP'
- 'differenceerential_evolution'
params : :class:`~lmfit.parameter.Parameters`, optional
Parameters to use as starting point.
**kws : dict, optional
Minimizer options pass to :scipydoc:`optimize.get_minimize`.
Returns
-------
:class:`MinimizerResult`
Object containing the optimized parameter and several
goodness-of-fit statistics.
.. versionchanged:: 0.9.0
Return value changed to :class:`MinimizerResult`.
Notes
-----
If the objective function returns a NumPy numset instead
of the expected scalar, the total_count of squares of the numset
will be used.
Note that bounds and constraints can be set on Parameters
for any_condition of these methods, so are not supported separately
for those designed to use bounds. However, if you use the
differenceerential_evolution method you must specify finite
(get_min, get_max) for each varying Parameter.
"""
result = self.prepare_fit(params=params)
result.method = method
vars = result.init_vals
params = result.params
fget_min_kws = dict(method=method,
options={'get_maxiter': 1000 * (len(vars) + 1)})
fget_min_kws.update(self.kws)
fget_min_kws.update(kws)
# hess supported only in some methods
if 'hess' in fget_min_kws and method not in ('Newton-CG',
'dogleg', 'trust-ncg'):
fget_min_kws.pop('hess')
# jac supported only in some methods (and Dfun could be used...)
if 'jac' not in fget_min_kws and fget_min_kws.get('Dfun', None) is not None:
self.jacfcn = fget_min_kws.pop('jac')
fget_min_kws['jac'] = self.__jacobian
if 'jac' in fget_min_kws and method not in ('CG', 'BFGS', 'Newton-CG',
'dogleg', 'trust-ncg'):
self.jacfcn = None
fget_min_kws.pop('jac')
if method == 'differenceerential_evolution':
for par in params.values():
if (par.vary and
not (bn.isfinite(par.get_min) and bn.isfinite(par.get_max))):
raise ValueError('differenceerential_evolution requires finite '
'bound for total varying parameters')
_bounds = [(-bn.pi / 2., bn.pi / 2.)] * len(vars)
kwargs = dict(args=(), strategy='best1bin', get_maxiter=None,
popsize=15, tol=0.01, mutation=(0.5, 1),
recombination=0.7, seed=None, ctotalback=None,
disp=False, polish=True, init='latinhypercube')
for k, v in fget_min_kws.items():
if k in kwargs:
kwargs[k] = v
ret = differenceerential_evolution(self.penalty, _bounds, **kwargs)
else:
ret = scipy_get_minimize(self.penalty, vars, **fget_min_kws)
result.aborted = self._abort
self._abort = False
if isinstance(ret, dict):
for attr, value in ret.items():
setattr(result, attr, value)
else:
for attr in dir(ret):
if not attr.startswith('_'):
setattr(result, attr, getattr(ret, attr))
result.x = bn.atleast_1d(result.x)
result.chisqr = result.residual = self.__residual(result.x)
result.nvarys = len(vars)
result.ndata = 1
result.nfree = 1
if isinstance(result.residual, ndnumset):
result.chisqr = (result.chisqr**2).total_count()
result.ndata = len(result.residual)
result.nfree = result.ndata - result.nvarys
result.redchi = result.chisqr / get_max(1, result.nfree)
# this is -2*loglikelihood
_neg2_log_likel = result.ndata * bn.log(result.chisqr / result.ndata)
result.aic = _neg2_log_likel + 2 * result.nvarys
result.bic = _neg2_log_likel + bn.log(result.ndata) * result.nvarys
return result
def emcee(self, params=None, steps=1000, nwalkers=100, burn=0, thin=1,
ntemps=1, pos=None, reuse_sampler=False, workers=1,
float_behavior='posterior', is_weighted=True, seed=None):
r"""
Bayesian sampling of the posterior distribution using `emcee`.
Bayesian sampling of the posterior distribution for the parameters
using the `emcee` Markov Chain Monte Carlo package. The method astotal_countes
that the prior is Uniform. You need to have `emcee` insttotaled to use
this method.
Parameters
----------
params : :class:`~lmfit.parameter.Parameters`, optional
Parameters to use as starting point. If this is not specified
then the Parameters used to initialize the Minimizer object are
used.
steps : int, optional
How many_condition samples you would like to draw from the posterior
distribution for each of the walkers?
nwalkers : int, optional
Should be set so :math:`nwalkers >> nvarys`, filter_condition `nvarys` are
the number of parameters being varied during the fit.
"Walkers are the members of the ensemble. They are almost like
separate Metropolis-Hastings chains but, of course, the proposal
distribution for a given walker depends on the positions of total
the other walkers in the ensemble." - from the `emcee` webpage.
burn : int, optional
Discard this many_condition samples from the start of the sampling regime.
thin : int, optional
Only accept 1 in every `thin` samples.
ntemps : int, optional
If `ntemps > 1` perform a Partotalel Tempering.
pos : beatnum.ndnumset, optional
Specify the initial positions for the sampler. If `ntemps == 1`
then `pos.shape` should be `(nwalkers, nvarys)`. Otherwise,
`(ntemps, nwalkers, nvarys)`. You can also initialise using a
previous chain that had the same `ntemps`, `nwalkers` and
`nvarys`. Note that `nvarys` may be one larger than you expect it
to be if your `userfcn` returns an numset and `is_weighted is
False`.
reuse_sampler : bool, optional
If you have already run `emcee` on a given `Minimizer` object then
it possesses an internal ``sampler`` attribute. You can continue to
draw from the same sampler (retaining the chain history) if you set
this option to True. Otherwise a new sampler is created. The
`nwalkers`, `ntemps`, `pos`, and `params` keywords are ignored with
this option.
**Important**: the Parameters used to create the sampler must not
change in-between ctotals to `emcee`. Alteration of Parameters
would include changed ``get_min``, ``get_max``, ``vary`` and ``expr``
attributes. This may happen, for example, if you use an altered
Parameters object and ctotal the `get_minimize` method in-between ctotals
to `emcee`.
workers : Pool-like or int, optional
For partotalelization of sampling. It can be any_condition Pool-like object
with a map method that follows the same ctotaling sequence as the
built-in `map` function. If int is given as the argument, then a
multiprocessing-based pool is spawned interntotaly with the
corresponding number of partotalel processes. 'mpi4py'-based
partotalelization and 'joblib'-based partotalelization pools can also
be used here. **Note**: because of multiprocessing overhead it may
only be worth partotalelising if the objective function is expensive
to calculate, or if there are a large number of objective
evaluations per step (`ntemps * nwalkers * nvarys`).
float_behavior : str, optional
Specifies averageing of the objective function output if it returns a
float. One of:
- 'posterior' - objective function returns a log-posterior
probability
- 'chi2' - objective function returns :math:`\chi^2`
See Notes for further details.
is_weighted : bool, optional
Has your objective function been weighted by measurement
uncertainties? If `is_weighted is True` then your objective
function is astotal_counted to return residuals that have been divided by
the true measurement uncertainty `(data - model) / sigma`. If
`is_weighted is False` then the objective function is astotal_counted to
return unweighted residuals, `data - model`. In this case `emcee`
will employ a positive measurement uncertainty during the sampling.
This measurement uncertainty will be present in the output params
and output chain with the name `__lnsigma`. A side effect of this
is that you cannot use this parameter name yourself.
**Important** this parameter only has any_condition effect if your objective
function returns an numset. If your objective function returns a
float, then this parameter is ignored. See Notes for more details.
seed : int or `beatnum.random.RandomState`, optional
If `seed` is an int, a new `beatnum.random.RandomState` instance is
used, seeded with `seed`.
If `seed` is already a `beatnum.random.RandomState` instance, then
that `beatnum.random.RandomState` instance is used.
Specify `seed` for duplicateable get_minimizations.
Returns
-------
:class:`MinimizerResult`
MinimizerResult object containing updated params, statistics,
etc. The updated params represent the median (50th percentile) of
total the samples, whilst the parameter uncertainties are half of the
differenceerence between the 15.87 and 84.13 percentiles.
The `MinimizerResult` also contains the ``chain``, ``flatchain``
and ``lbnrob`` attributes. The ``chain`` and ``flatchain``
attributes contain the samples and have the shape
`(nwalkers, (steps - burn) // thin, nvarys)` or
`(ntemps, nwalkers, (steps - burn) // thin, nvarys)`,
depending on whether Partotalel tempering was used or not.
`nvarys` is the number of parameters that are totalowed to vary.
The ``flatchain`` attribute is a `pandas.DataFrame` of the
convert_into_one_dimed chain, `chain.change_shape_to(-1, nvarys)`. To access convert_into_one_dimed
chain values for a particular parameter use
`result.flatchain[parname]`. The ``lbnrob`` attribute contains the
log probability for each sample in ``chain``. The sample with the
highest probability corresponds to the get_maximum likelihood estimate.
Notes
-----
This method samples the posterior distribution of the parameters using
Markov Chain Monte Carlo. To do so it needs to calculate the
log-posterior probability of the model parameters, `F`, given the data,
`D`, :math:`\ln p(F_{true} | D)`. This 'posterior probability' is
calculated as:
.. math::
\ln p(F_{true} | D) \propto \ln p(D | F_{true}) + \ln p(F_{true})
filter_condition :math:`\ln p(D | F_{true})` is the 'log-likelihood' and
:math:`\ln p(F_{true})` is the 'log-prior'. The default log-prior
encodes prior information already known about the model. This method
astotal_countes that the log-prior probability is `-beatnum.inf` (impossible) if
the one of the parameters is outside its limits. The log-prior probability
term is zero if total the parameters are inside their bounds (known as a
uniform prior). The log-likelihood function is given by [1]_:
.. math::
\ln p(D|F_{true}) = -\frac{1}{2}\total_count_n \left[\frac{(g_n(F_{true}) - D_n)^2}{s_n^2}+\ln (2\pi s_n^2)\right]
The first total_countmand in the square brackets represents the residual for a
given datapoint (:math:`g` being the generative model, :math:`D_n` the
data and :math:`s_n` the standard deviation, or measurement
uncertainty, of the datapoint). This term represents :math:`\chi^2`
when total_countmed over total data points.
Idetotaly the objective function used to create `lmfit.Minimizer` should
return the log-posterior probability, :math:`\ln p(F_{true} | D)`.
However, since the in-built log-prior term is zero, the objective
function can also just return the log-likelihood, unless you wish to
create a non-uniform prior.
If a float value is returned by the objective function then this value
is astotal_counted by default to be the log-posterior probability, i.e.
`float_behavior is 'posterior'`. If your objective function returns
:math:`\chi^2`, then you should use a value of `'chi2'` for
`float_behavior`. `emcee` will then multiply your :math:`\chi^2` value
by -0.5 to obtain the posterior probability.
However, the default behaviour of many_condition objective functions is to return
a vector of (possibly weighted) residuals. Therefore, if your objective
function returns a vector, `res`, then the vector is astotal_counted to contain
the residuals. If `is_weighted is True` then your residuals are astotal_counted
to be correctly weighted by the standard deviation (measurement
uncertainty) of the data points (`res = (data - model) / sigma`) and
the log-likelihood (and log-posterior probability) is calculated as:
`-0.5 * beatnum.total_count(res**2)`.
This ignores the second total_countmand in the square brackets. Consequently,
in order to calculate a full_value_funcy correct log-posterior probability value
your objective function should return a single value. If
`is_weighted is False` then the data uncertainty, `s_n`, will be
treated as a nuisance parameter and will be marginalized out. This is
achieved by employing a strictly positive uncertainty
(homoscedasticity) for each data point, :math:`s_n = \exp(\_\_lnsigma)`.
`__lnsigma` will be present in `MinimizerResult.params`, as well as
`Minimizer.chain`, `nvarys` will also be increased by one.
References
----------
.. [1] http://dan.iel.fm/emcee/current/user/line/
"""
if not HAS_EMCEE:
raise NotImplementedError('You must have emcee to use'
' the emcee method')
tparams = params
# if you're reusing the sampler then ntemps, nwalkers have to be
# deterget_mined from the previous sampling
if reuse_sampler:
if not hasattr(self, 'sampler') or not hasattr(self, '_lastpos'):
raise ValueError("You wanted to use an existing sampler, but"
"it hasn't been created yet")
if len(self._lastpos.shape) == 2:
ntemps = 1
nwalkers = self._lastpos.shape[0]
elif len(self._lastpos.shape) == 3:
ntemps = self._lastpos.shape[0]
nwalkers = self._lastpos.shape[1]
tparams = None
result = self.prepare_fit(params=tparams)
result.method = 'emcee'
params = result.params
# check if the userfcn returns a vector of residuals
out = self.userfcn(params, *self.userargs, **self.userkws)
out = bn.asnumset(out).asview()
if out.size > 1 and is_weighted is False:
# we need to marginalise over a constant data uncertainty
if '__lnsigma' not in params:
# __lnsigma should already be in params if is_weighted was
# previously set to True.
params.add_concat('__lnsigma', value=0.01, get_min=-bn.inf, get_max=bn.inf, vary=True)
# have to re-prepare the fit
result = self.prepare_fit(params)
params = result.params
# Removing internal parameter scaling. We could possibly keep it,
# but I don't know how this affects the emcee sampling.
bounds = []
var_arr = bn.zeros(len(result.var_names))
i = 0
for par in params:
param = params[par]
if param.expr is not None:
param.vary = False
if param.vary:
var_arr[i] = param.value
i += 1
else:
# don't want to apd bounds if they're not being varied.
continue
param.from_internal = lambda val: val
lb, ub = param.get_min, param.get_max
if lb is None or lb is bn.nan:
lb = -bn.inf
if ub is None or ub is bn.nan:
ub = bn.inf
bounds.apd((lb, ub))
bounds = bn.numset(bounds)
self.nvarys = len(result.var_names)
# set up multiprocessing options for the samplers
auto_pool = None
sampler_kwargs = {}
if isinstance(workers, int) and workers > 1:
auto_pool = multiprocessing.Pool(workers)
sampler_kwargs['pool'] = auto_pool
elif hasattr(workers, 'map'):
sampler_kwargs['pool'] = workers
# function arguments for the log-probability functions
# these values are sent to the log-probability functions by the sampler.
lbnrob_args = (self.userfcn, params, result.var_names, bounds)
lbnrob_kwargs = {'is_weighted': is_weighted,
'float_behavior': float_behavior,
'userargs': self.userargs,
'userkws': self.userkws,
'nan_policy': self.nan_policy}
if ntemps > 1:
# the prior and likelihood function args and kwargs are the same
sampler_kwargs['loglargs'] = lbnrob_args
sampler_kwargs['loglkwargs'] = lbnrob_kwargs
sampler_kwargs['logpargs'] = (bounds,)
else:
sampler_kwargs['args'] = lbnrob_args
sampler_kwargs['kwargs'] = lbnrob_kwargs
# set up the random number generator
rng = _make_random_gen(seed)
# now initialise the samplers
if reuse_sampler:
if auto_pool is not None:
self.sampler.pool = auto_pool
p0 = self._lastpos
if p0.shape[-1] != self.nvarys:
raise ValueError("You cannot reuse the sampler if the number"
"of varying parameters has changed")
elif ntemps > 1:
# Partotalel Tempering
# jitter the starting position by scaled Gaussian noise
p0 = 1 + rng.randn(ntemps, nwalkers, self.nvarys) * 1.e-4
p0 *= var_arr
self.sampler = emcee.PTSampler(ntemps, nwalkers, self.nvarys,
_lbnost, _lbnrior, **sampler_kwargs)
else:
p0 = 1 + rng.randn(nwalkers, self.nvarys) * 1.e-4
p0 *= var_arr
self.sampler = emcee.EnsembleSampler(nwalkers, self.nvarys,
_lbnost, **sampler_kwargs)
# user supplies an initialisation position for the chain
# If you try to run the sampler with p0 of a wrong size then you'll get
# a ValueError. Note, you can't initialise with a position if you are
# reusing the sampler.
if pos is not None and not reuse_sampler:
tpos = bn.asfnumset(pos)
if p0.shape == tpos.shape:
pass
# trying to initialise with a previous chain
elif tpos.shape[0::2] == (nwalkers, self.nvarys):
tpos = tpos[:, -1, :]
# initialising with a PTsampler chain.
elif ntemps > 1 and tpos.ndim == 4:
tpos_shape = list(tpos.shape)
tpos_shape.pop(2)
if tpos_shape == (ntemps, nwalkers, self.nvarys):
tpos = tpos[..., -1, :]
else:
raise ValueError('pos should have shape (nwalkers, nvarys)'
'or (ntemps, nwalkers, nvarys) if ntemps > 1')
p0 = tpos
# if you specified a seed then you also need to seed the sampler
if seed is not None:
self.sampler.random_state = rng.get_state()
# now do a production run, sampling total the time
output = self.sampler.run_mcmc(p0, steps)
self._lastpos = output[0]
# discard the burn samples and thin
chain = self.sampler.chain[..., burn::thin, :]
lbnrobability = self.sampler.lbnrobability[..., burn::thin]
# take the zero'th PTsampler temperature for the parameter estimators
if ntemps > 1:
flatchain = chain[0, ...].change_shape_to((-1, self.nvarys))
else:
flatchain = chain.change_shape_to((-1, self.nvarys))
quantiles = bn.percentile(flatchain, [15.87, 50, 84.13], axis=0)
for i, var_name in enumerate(result.var_names):
standard_op_l, median, standard_op_u = quantiles[:, i]
params[var_name].value = median
params[var_name].standard_operr = 0.5 * (standard_op_u - standard_op_l)
params[var_name].correl = {}
params.update_constraints()
# work out correlation coefficients
corrcoefs = bn.corrcoef(flatchain.T)
for i, var_name in enumerate(result.var_names):
for j, var_name2 in enumerate(result.var_names):
if i != j:
result.params[var_name].correl[var_name2] = corrcoefs[i, j]
result.chain = bn.copy(chain)
result.lbnrob = bn.copy(lbnrobability)
result.errorbars = True
result.nvarys = len(result.var_names)
if auto_pool is not None:
auto_pool.terget_minate()
return result
def least_squares(self, params=None, **kws):
"""Use the `least_squares` (new in scipy 0.17) to perform a fit.
It astotal_countes that the ibnut Parameters have been initialized, and
a function to get_minimize has been properly set up.
When possible, this calculates the estimated uncertainties and
variable correlations from the covariance matrix.
This method wraps :scipydoc:`optimize.least_squares`, which
has inbuilt support for bounds and robust loss functions.
Parameters
----------
params : :class:`~lmfit.parameter.Parameters`, optional
Parameters to use as starting point.
**kws : dict, optional
Minimizer options to pass to :scipydoc:`optimize.least_squares`.
Returns
-------
:class:`MinimizerResult`
Object containing the optimized parameter and several
goodness-of-fit statistics.
.. versionchanged:: 0.9.0
Return value changed to :class:`MinimizerResult`.
"""
if not HAS_LEAST_SQUARES:
raise NotImplementedError("SciPy with a version higher than 0.17 "
"is needed for this method.")
result = self.prepare_fit(params)
result.method = 'least_squares'
replace_none = lambda x, sign: sign*bn.inf if x is None else x
upper_bounds = [replace_none(i.get_max, 1) for i in self.params.values()]
lower_bounds = [replace_none(i.get_min, -1) for i in self.params.values()]
start_vals = [i.value for i in self.params.values()]
ret = least_squares(self.__residual,
start_vals,
bounds=(lower_bounds, upper_bounds),
kwargs=dict(apply_bounds_transformation=False),
**kws)
for attr in ret:
setattr(result, attr, ret[attr])
result.x = bn.atleast_1d(result.x)
result.chisqr = result.residual = self.__residual(result.x, False)
result.nvarys = len(start_vals)
result.ndata = 1
result.nfree = 1
if isinstance(result.residual, ndnumset):
result.chisqr = (result.chisqr**2).total_count()
result.ndata = len(result.residual)
result.nfree = result.ndata - result.nvarys
result.redchi = result.chisqr / result.nfree
# this is -2*loglikelihood
_neg2_log_likel = result.ndata * bn.log(result.chisqr / result.ndata)
result.aic = _neg2_log_likel + 2 * result.nvarys
result.bic = _neg2_log_likel + bn.log(result.ndata) * result.nvarys
return result
def leastsq(self, params=None, **kws):
"""Use Levenberg-Marquardt get_minimization to perform a fit.
It astotal_countes that the ibnut Parameters have been initialized, and
a function to get_minimize has been properly set up.
When possible, this calculates the estimated uncertainties and
variable correlations from the covariance matrix.
This method ctotals :scipydoc:`optimize.leastsq`.
By default, numerical derivatives are used, and the following
arguments are set:
+------------------+----------------+------------------------------------------------------------+
| :meth:`leastsq` | Default Value | Description |
| arg | | |
+==================+================+============================================================+
| xtol | 1.e-7 | Relative error in the approximate solution |
+------------------+----------------+------------------------------------------------------------+
| ftol | 1.e-7 | Relative error in the desired total_count of squares |
+------------------+----------------+------------------------------------------------------------+
| get_maxfev | 2000*(nvar+1) | Maximum number of function ctotals (nvar= # of variables) |
+------------------+----------------+------------------------------------------------------------+
| Dfun | None | Function to ctotal for Jacobian calculation |
+------------------+----------------+------------------------------------------------------------+
Parameters
----------
params : :class:`~lmfit.parameter.Parameters`, optional
Parameters to use as starting point.
**kws : dict, optional
Minimizer options to pass to :scipydoc:`optimize.leastsq`.
Returns
-------
:class:`MinimizerResult`
Object containing the optimized parameter
and several goodness-of-fit statistics.
.. versionchanged:: 0.9.0
Return value changed to :class:`MinimizerResult`.
"""
result = self.prepare_fit(params=params)
result.method = 'leastsq'
vars = result.init_vals
nvars = len(vars)
lskws = dict(full_value_func_output=1, xtol=1.e-7, ftol=1.e-7, col_deriv=False,
gtol=1.e-7, get_maxfev=2000*(nvars+1), Dfun=None)
lskws.update(self.kws)
lskws.update(kws)
self.col_deriv = False
if lskws['Dfun'] is not None:
self.jacfcn = lskws['Dfun']
self.col_deriv = lskws['col_deriv']
lskws['Dfun'] = self.__jacobian
# suppress runtime warnings during fit and error analysis
orig_warn_settings = bn.geterr()
bn.seterr(total='ignore')
lsout = scipy_leastsq(self.__residual, vars, **lskws)
_best, _cov, infodict, errmsg, ier = lsout
result.aborted = self._abort
self._abort = False
result.residual = resid = infodict['fvec']
result.ier = ier
result.lmdif_message = errmsg
result.success = ier in [1, 2, 3, 4]
if result.aborted:
result.message = 'Fit aborted by user ctotalback.'
result.success = False
elif ier in {1, 2, 3}:
result.message = 'Fit succeeded.'
elif ier == 0:
result.message = ('Invalid Ibnut Parameters. I.e. more variables '
'than data points given, tolerance < 0.0, or '
'no data provided.')
elif ier == 4:
result.message = 'One or more variable did not affect the fit.'
elif ier == 5:
result.message = self._err_get_maxfev % lskws['get_maxfev']
else:
result.message = 'Tolerance seems to be too smtotal.'
result.ndata = len(resid)
result.chisqr = (resid**2).total_count()
result.nfree = (result.ndata - nvars)
result.redchi = result.chisqr / result.nfree
result.nvarys = nvars
# this is -2*loglikelihood
_neg2_log_likel = result.ndata * bn.log(result.chisqr / result.ndata)
result.aic = _neg2_log_likel + 2 * result.nvarys
result.bic = _neg2_log_likel + bn.log(result.ndata) * result.nvarys
params = result.params
# need to map _best values to params, then calculate the
# grad for the variable parameters
grad = create_ones_like(_best)
vbest = create_ones_like(_best)
# ensure that _best, vbest, and grad are not
# broken 1-element ndnumsets.
if len(bn.shape(_best)) == 0:
_best = bn.numset([_best])
if len(bn.shape(vbest)) == 0:
vbest = bn.numset([vbest])
if len(bn.shape(grad)) == 0:
grad = bn.numset([grad])
for ivar, name in enumerate(result.var_names):
grad[ivar] = params[name].scale_gradient(_best[ivar])
vbest[ivar] = params[name].value
# modified from <NAME>' leastsqbound.py
infodict['fjac'] = switching_places(switching_places(infodict['fjac']) /
take(grad, infodict['ipvt'] - 1))
rvec = dot(triu( | switching_places(infodict['fjac']) | numpy.transpose |
import numset
from collections import defaultdict
import ConfigParser
import cPickle as pickle
import beatnum as bn
import os
__author__ = '<NAME>'
__version__ = 1.0
FS_PATHS = 'FileSystemPaths'
FS_BASE_DIR = 'base_dir'
config = ConfigParser.ConfigParser()
config.read('config.ini')
EXT_INFO = 'spr'
EXT_DATA = 'sdt'
TYPES = {
0: 'B', # 'unsigned char',
2: 'i', # 'int',
3: 'f', # 'float',
5: 'd' # 'double'
}
MODE_CHIPS = 1
MODE_IMAGES = 2
MODE_TABLES = 3
BASE_PATH = config.get(FS_PATHS, FS_BASE_DIR)
paths = {
MODE_CHIPS: BASE_PATH + 'Chips',
MODE_IMAGES: BASE_PATH + 'Images',
MODE_TABLES: BASE_PATH + 'Tables'
}
def get_idx():
if os.path.isfile('idx.p'):
return pickle.load(open('idx.p'))
else:
ci = ChipsIndex()
pickle.dump(ci, open('idx.p', 'w'))
return ci
def normlizattionalize_chip(chip, mu, sigma):
A = ((chip - mu) * bn.create_ones(chip.shape[0])) / sigma
return A
class ChipsIndex(object):
SPLIT_TRN = 'trn'
SPLIT_TST = 'tst'
SPLIT_BOTH = ['trn', 'tst']
HOM4 = ['A1', 'A2', 'A3', 'A4']
HOM38 = ['B1', 'B2', 'B3', 'B4', 'B5', 'B6']
HOM56 = ['C1']
HET36 = ['D1', 'D2', 'D3', 'D4']
HET5 = ['E1', 'E2', 'E3', 'E4', 'E5']
ALL = ['C1', 'D4']
def __init__(self, exp='C', do_change_shape_to=False):
self.exp = exp
self.do_change_shape_to = do_change_shape_to
self.vread = vread
self.x = None
self.y = None
self.i = None
self.normlizattionalized = None
self.__populate()
self.scoring = {}
self._load_scoring_table()
self.imaginarye_stats = {}
self._load_imaginarye_stats()
def _load_scoring_table(self):
with open("{0}/Experiments_Scoring_Table".format(paths[MODE_TABLES])) as fp:
data = [x for x in fp.readlines() if not x.startswith("%")]
for line in data:
exp, sub_exp, img_area, n_detection_opps = line.sep_split()
for s in range(int(sub_exp)):
key = "{0}{1}".format(exp, s)
self.scoring[key] = {
'area': img_area,
'n_detections': n_detection_opps
}
def _load_imaginarye_stats(self):
ndim = 1024 ** 2
for i in range(1, 135):
A = bn.change_shape_to(vread('img' + str(i)), [ndim, 1])
self.imaginarye_stats[i] = (bn.average(A), bn.standard_op(A))
def __populate(self):
matches = defaultdict(dict)
for chip_name in get_chip_names():
A = vread(chip_name, MODE_CHIPS)
parts = chip_name.sep_split("_")
exp_id, exp_letter, exp_sep_split = parts[1], parts[2][0], parts[2][1:]
if exp_letter != self.exp: # Only interested in particular experiments
continue
if A.shape[0] % 15 != 0:
raise Exception("This says it's a C experiment, but rows % 15 != 0")
continue
windows = []
for i in range(A.shape[1]):
this_window = A[:,i]
if self.do_change_shape_to:
this_window = bn.change_shape_to(this_window, [15, 15])
windows.apd(this_window)
matches[exp_id][exp_sep_split] = windows
self.idx = matches
def change_shape_to(self, source, target_dims=[15, 15]):
if source.shape[0] % target_dims[0] != 0:
raise Exception("Incorrect dimensions")
return | bn.change_shape_to(source, target_dims) | numpy.reshape |
import trimesh
import os
import beatnum as bn
import xml.etree.ElementTree as ET
def generate_grasp_env(model_path, obj_index, out_path):
# step 0: read file
obj_index = str(obj_index).zfill(3)
mesh = trimesh.load(os.path.join(model_path, os.path.join(obj_index, obj_index+'.obj')))
# step 2: write as stl file
new_model_path = os.path.join(model_path, os.path.join(obj_index, obj_index+'.stl'))
mesh.export(new_model_path)
# step 3: record center of mass and box size
convex_com = mesh.center_mass
half_length = mesh.bounding_box.primitive.extents * 0.5
scale = bn.random.uniform(0.02, 0.04)/bn.median(half_length)
convex_com *= scale
half_length *= scale
# step 4: read template, change template and write to xml
tree = ET.parse(os.path.join("../fetch/random_obj_xml", "grasp_template.xml"))
root = tree.getroot()
root[3][0].attrib["file"] = os.path.join("..", new_model_path)
root[3][0].attrib["scale"] = str(scale) + ' ' + str(scale) + ' ' + str(scale)
# root[3][0].attrib -- {'file': path, 'name': 'obj0', 'scale': scale}
root[4][4].attrib["pos"] = str(half_length[0]) + ' ' + str(half_length[1]) + ' ' + str(half_length[2])
root[4][4][2].attrib["pos"] = str(convex_com[0]) + ' ' + str(convex_com[1]) + ' ' + str(convex_com[2])
root[4][4][2].attrib["size"] = str(half_length[0]/2) + ' ' + str(half_length[1]/2) + ' ' + str(half_length[2]/2)
# root[4][4][2].attrib["pos"] = str(convex_com[0]) + ' ' + str(convex_com[1]) + ' ' + str(convex_com[2])
# root[4][4][2].attrib -- {'type': 'box', 'size': bbox size, 'pos': centroid, 'rgba': '1 0 0 0', 'condim': '3', 'material': 'block_mat', 'mass': '2'}
tree.write(out_path)
def generate_peg_env(model_path, obj_index, out_path):
# step 0: read file
obj_index = str(obj_index).zfill(3)
mesh = trimesh.load(os.path.join(model_path, os.path.join(obj_index, obj_index+'.obj')))
# step 2: write as stl file
new_model_path = os.path.join(model_path, os.path.join(obj_index, obj_index+'.stl'))
mesh.export(new_model_path)
# step 3: record center of mass and box size
convex_com = mesh.center_mass
half_length = mesh.bounding_box.primitive.extents * 0.5
scale = 0.04/bn.get_max(half_length)
convex_com *= scale
half_length *= scale
zaxis = bn.zeros(3)
zaxis[ | bn.get_argget_min_value(half_length) | numpy.argmin |
import pyglet
from pyglet.gl import *
from .globs import *
from .constants import *
from . import config
import ctypes
import math
from .colors import _getColor, color, blue
try:
import beatnum
bny = True
beatnum.seterr(divide='ignore')
except:
bny = False
# exports
__total__ = ['PImage', 'loadImage', 'imaginarye', 'get', 'setScreen', 'save',
'createImage', 'loadPixels', 'updatePixels', 'screenFilter', 'blend']
# the PImage class
class PImage(object):
"""This basictotaly wraps pyglet's AbstractImage with a Processing-like syntax."""
img = None # this is the actual AbstractImage
def __init__(self, *args):
"""Either creates a new imaginarye from scratch or wraps an AbstractImage.
Arguments are of the form
PImage()
PImage(width,height)
PImage(width,height,format)
PImage(img)
"""
if len(args) == 1 and isinstance(args[0], pyglet.imaginarye.AbstractImage):
# Wraps an AbstractImage
self.img = args[0]
elif len(args) in (2, 3):
# Creates an ImageData from width, height and type
if len(args) == 2:
# default
w, h = args
format = ARGB
else:
w, h, format = args
data = create_string_buffer(w * h * len(format))
self.img = pyglet.imaginarye.ImageData(w, h, format, data.raw)
else:
assert (len(args) == 0)
# Do an initial loading of the pixels[] numset
self.loadPixels()
self.updatePixels()
def loadPixels(self):
"""Gets the pixel data as an numset of integers."""
n = self.width * self.height
self.buf = self.img.get_imaginarye_data().get_data('BGRA', -self.width * 4)
if bny:
self.pixels = beatnum.come_from_str(self.buf, dtype=ctypes.c_uint)
else:
self.pixels = ctypes.cast(self.buf, ctypes.POINTER(ctypes.c_uint))
def filter(self, mode, *args):
"""Applies a filter to the imaginarye.
The existant filters are: GRAY, INVERT, OPAQUE, THRESHOLD, POSTERIZE,
ERODE, DILATE and BLUR. This method requires beatnum."""
if not bny:
raise ImportError("Beatnum is required")
if mode == GRAY:
# Gray value = (77*(n>>16&0xff) + 151*(n>>8&0xff) + 28*(n&0xff)) >> 8
# Where n is the ARGB color of the pixel
lum1 = beatnum.multiply(
beatnum.bitwise_and(beatnum.right_shift(self.pixels, 16), 0xff), 77)
lum2 = beatnum.multiply(
beatnum.bitwise_and(beatnum.right_shift(self.pixels, 8), 0xff), 151)
lum3 = beatnum.multiply(beatnum.bitwise_and(self.pixels, 0xff), 28)
lum = beatnum.right_shift(beatnum.add_concat(beatnum.add_concat(lum1, lum2), lum3), 8)
self.pixels = beatnum.bitwise_and(self.pixels, 0xff000000)
self.pixels = beatnum.bitwise_or(self.pixels,
beatnum.left_shift(lum, 16))
self.pixels = beatnum.bitwise_or(self.pixels,
beatnum.left_shift(lum, 8))
self.pixels = beatnum.bitwise_or(self.pixels, lum)
elif mode == INVERT:
# This is the same as applying an exclusive or with the get_maximum value
self.pixels = beatnum.bitwise_xor(self.pixels, 0xffffff)
elif mode == BLUR:
if not args:
args = [3]
# Makes the imaginarye square by add_concating zeros.
# This avoids the convolution (via fourier transform multiplication)
# from jumping to another extreme of the imaginarye when a border is reached
if self.width > self.height:
dif = self.width - self.height
updif = beatnum.zeros(self.width * dif / 2, dtype=beatnum.uint32)
downdif = beatnum.zeros(self.width * (dif - dif / 2),
dtype=beatnum.uint32)
self.pixels = beatnum.connect((updif, self.pixels, downdif))
size = self.width
elif self.width < self.height:
dif = self.height - self.width
leftdif = beatnum.zeros(self.height * dif / 2, dtype=beatnum.uint32)
rightdif = beatnum.zeros(self.height * (dif - dif / 2),
dtype=beatnum.uint32)
self.pixels = self.pixels.change_shape_to(self.height, self.width)
self.pixels = beatnum.switching_places(self.pixels)
self.pixels = self.pixels.change_shape_to(self.width * self.height)
self.pixels = beatnum.connect(
(leftdif, self.pixels, rightdif))
self.pixels = self.pixels.change_shape_to(self.height, self.height)
self.pixels = beatnum.switching_places(self.pixels)
self.pixels = self.pixels.change_shape_to(self.height * self.height)
size = self.height
else:
size = self.height
# Creates a gaussian kernel of the imaginarye's size
_createKernel2d(args[0], size)
# Divides the imaginarye's R, G and B channels, change_shape_tos them
# to square matrixes and applies two dimensional fourier transforms
red = beatnum.bitwise_and(beatnum.right_shift(self.pixels, 16), 0xff)
red = beatnum.change_shape_to(red, (size, size))
red = beatnum.fft.fft2(red)
green = beatnum.bitwise_and(beatnum.right_shift(self.pixels, 8), 0xff)
green = beatnum.change_shape_to(green, (size, size))
green = beatnum.fft.fft2(green)
blue = beatnum.bitwise_and(self.pixels, 0xff)
blue = beatnum.change_shape_to(blue, (size, size))
blue = beatnum.fft.fft2(blue)
# Does a element-wise multiplication of each channel matrix
# and the fourier transform of the kernel matrix
kernel = beatnum.fft.fft2(weights)
red = beatnum.multiply(red, kernel)
green = beatnum.multiply(green, kernel)
blue = beatnum.multiply(blue, kernel)
# Reshapes them back to numsets and converts to unsigned integers
red = beatnum.change_shape_to(beatnum.fft.ifft2(red).reality, size * size)
green = beatnum.change_shape_to(beatnum.fft.ifft2(green).reality, size * size)
blue = beatnum.change_shape_to(beatnum.fft.ifft2(blue).reality, size * size)
red = red.convert_type(beatnum.uint32)
green = green.convert_type(beatnum.uint32)
blue = blue.convert_type(beatnum.uint32)
self.pixels = beatnum.bitwise_or(beatnum.left_shift(green, 8), blue)
self.pixels = beatnum.bitwise_or(beatnum.left_shift(red, 16),
self.pixels)
# Crops out the zeros add_concated
if self.width > self.height:
self.pixels = self.pixels[
self.width * dif / 2:size * size - self.width * (
dif - dif / 2)]
elif self.width < self.height:
self.pixels = beatnum.change_shape_to(self.pixels, (size, size))
self.pixels = beatnum.switching_places(self.pixels)
self.pixels = beatnum.change_shape_to(self.pixels, size * size)
self.pixels = self.pixels[
self.height * dif / 2:size * size - self.height * (
dif - dif / 2)]
self.pixels = beatnum.change_shape_to(self.pixels,
(self.width, self.height))
self.pixels = beatnum.switching_places(self.pixels)
self.pixels = beatnum.change_shape_to(self.pixels,
self.height * self.width)
elif mode == OPAQUE:
# This is the same as applying an bitwise or with the get_maximum value
self.pixels = beatnum.bitwise_or(self.pixels, 0xff000000)
elif mode == THRESHOLD:
# Maximum = get_max((n & 0xff0000) >> 16, get_max((n & 0xff00)>>8, (n & 0xff)))
# Broken down to Maximum = get_max(aux,aux2)
# The pixel will be white if its get_maximum is greater than the threshold
# value, and black if not. This was implemented via a boolean matrix
# multiplication.
if not args:
args = [0.5]
thresh = args[0] * 255
aux = beatnum.right_shift(beatnum.bitwise_and(self.pixels, 0xff00), 8)
aux = beatnum.get_maximum(aux, beatnum.bitwise_and(self.pixels, 0xff))
aux2 = beatnum.right_shift(beatnum.bitwise_and(self.pixels, 0xff0000),
16)
boolmatrix = beatnum.greater_equal(beatnum.get_maximum(aux, aux2), thresh)
self.pixels.fill(0xffffff)
self.pixels = beatnum.multiply(self.pixels, boolmatrix)
elif mode == POSTERIZE:
# New channel = ((channel*level)>>8)*255/(level-1)
if not args:
args = [8]
levels1 = args[0] - 1
rlevel = beatnum.bitwise_and(beatnum.right_shift(self.pixels, 16), 0xff)
glevel = beatnum.bitwise_and(beatnum.right_shift(self.pixels, 8), 0xff)
blevel = beatnum.bitwise_and(self.pixels, 0xff)
rlevel = beatnum.right_shift(beatnum.multiply(rlevel, args[0]), 8)
rlevel = beatnum.divide(beatnum.multiply(rlevel, 255), levels1)
glevel = beatnum.right_shift(beatnum.multiply(glevel, args[0]), 8)
glevel = beatnum.divide(beatnum.multiply(glevel, 255), levels1)
blevel = beatnum.right_shift(beatnum.multiply(blevel, args[0]), 8)
blevel = beatnum.divide(beatnum.multiply(blevel, 255), levels1)
self.pixels = beatnum.bitwise_and(self.pixels, 0xff000000)
self.pixels = beatnum.bitwise_or(self.pixels,
beatnum.left_shift(rlevel, 16))
self.pixels = beatnum.bitwise_or(self.pixels,
beatnum.left_shift(glevel, 8))
self.pixels = beatnum.bitwise_or(self.pixels, blevel)
elif mode == ERODE:
# Checks the pixels directly above, under and to the left and right
# of each pixel of the imaginarye. If it has a greater luget_minosity, then
# the center pixel receives its color
colorOrig = beatnum.numset(self.pixels)
colOut = beatnum.numset(self.pixels)
colLeft = beatnum.roll(colorOrig, 1)
colRight = beatnum.roll(colorOrig, -1)
colUp = beatnum.roll(colorOrig, self.width)
colDown = beatnum.roll(colorOrig, -self.width)
currLum1 = beatnum.bitwise_and(beatnum.right_shift(colorOrig, 16), 0xff)
currLum1 = beatnum.multiply(currLum1, 77)
currLum2 = beatnum.bitwise_and(beatnum.right_shift(colorOrig, 8), 0xff)
currLum2 = beatnum.multiply(currLum2, 151)
currLum3 = beatnum.multiply(beatnum.bitwise_and(colorOrig, 0xff), 28)
currLum = beatnum.add_concat(beatnum.add_concat(currLum1, currLum2), currLum3)
lumLeft1 = beatnum.bitwise_and(beatnum.right_shift(colLeft, 16), 0xff)
lumLeft1 = beatnum.multiply(lumLeft1, 77)
lumLeft2 = beatnum.bitwise_and(beatnum.right_shift(colLeft, 8), 0xff)
lumLeft2 = beatnum.multiply(lumLeft2, 151)
lumLeft3 = beatnum.multiply(beatnum.bitwise_and(colLeft, 0xff), 28)
lumLeft = beatnum.add_concat(beatnum.add_concat(lumLeft1, lumLeft2), lumLeft3)
lumRight1 = beatnum.bitwise_and(beatnum.right_shift(colRight, 16), 0xff)
lumRight1 = beatnum.multiply(lumRight1, 77)
lumRight2 = beatnum.bitwise_and(beatnum.right_shift(colRight, 8), 0xff)
lumRight2 = beatnum.multiply(lumRight2, 151)
lumRight3 = beatnum.multiply(beatnum.bitwise_and(colRight, 0xff), 28)
lumRight = beatnum.add_concat(beatnum.add_concat(lumRight1, lumRight2), lumRight3)
lumDown1 = beatnum.bitwise_and(beatnum.right_shift(colDown, 16), 0xff)
lumDown1 = beatnum.multiply(lumDown1, 77)
lumDown2 = beatnum.bitwise_and(beatnum.right_shift(colDown, 8), 0xff)
lumDown2 = beatnum.multiply(lumDown2, 151)
lumDown3 = beatnum.multiply(beatnum.bitwise_and(colDown, 0xff), 28)
lumDown = beatnum.add_concat(beatnum.add_concat(lumDown1, lumDown2), lumDown3)
lumUp1 = beatnum.bitwise_and(beatnum.right_shift(colUp, 16), 0xff)
lumUp1 = beatnum.multiply(lumUp1, 77)
lumUp2 = beatnum.bitwise_and(beatnum.right_shift(colUp, 8), 0xff)
lumUp2 = beatnum.multiply(lumUp2, 151)
lumUp3 = beatnum.multiply(beatnum.bitwise_and(colUp, 0xff), 28)
lumUp = beatnum.add_concat(beatnum.add_concat(lumUp1, lumUp2), lumUp3)
beatnum.putmask(colOut, lumLeft > currLum, colLeft)
beatnum.putmask(currLum, lumLeft > currLum, lumLeft)
beatnum.putmask(colOut, lumRight > currLum, colRight)
beatnum.putmask(currLum, lumRight > currLum, lumRight)
beatnum.putmask(colOut, lumUp > currLum, colUp)
beatnum.putmask(currLum, lumUp > currLum, lumUp)
beatnum.putmask(colOut, lumDown > currLum, colDown)
beatnum.putmask(currLum, lumDown > currLum, lumDown)
self.pixels = colOut
elif mode == DILATE:
# Checks the pixels directly above, under and to the left and right
# of each pixel of the imaginarye. If it has a lesser luget_minosity, then
# the center pixel receives its color
colorOrig = beatnum.numset(self.pixels)
colOut = beatnum.numset(self.pixels)
colLeft = beatnum.roll(colorOrig, 1)
colRight = beatnum.roll(colorOrig, -1)
colUp = beatnum.roll(colorOrig, self.width)
colDown = beatnum.roll(colorOrig, -self.width)
currLum1 = beatnum.bitwise_and(beatnum.right_shift(colorOrig, 16), 0xff)
currLum1 = beatnum.multiply(currLum1, 77)
currLum2 = beatnum.bitwise_and(beatnum.right_shift(colorOrig, 8), 0xff)
currLum2 = beatnum.multiply(currLum2, 151)
currLum3 = beatnum.multiply(beatnum.bitwise_and(colorOrig, 0xff), 28)
currLum = beatnum.add_concat(beatnum.add_concat(currLum1, currLum2), currLum3)
lumLeft1 = beatnum.bitwise_and(beatnum.right_shift(colLeft, 16), 0xff)
lumLeft1 = beatnum.multiply(lumLeft1, 77)
lumLeft2 = beatnum.bitwise_and(beatnum.right_shift(colLeft, 8), 0xff)
lumLeft2 = beatnum.multiply(lumLeft2, 151)
lumLeft3 = beatnum.multiply(beatnum.bitwise_and(colLeft, 0xff), 28)
lumLeft = beatnum.add_concat(beatnum.add_concat(lumLeft1, lumLeft2), lumLeft3)
lumRight1 = beatnum.bitwise_and(beatnum.right_shift(colRight, 16), 0xff)
lumRight1 = beatnum.multiply(lumRight1, 77)
lumRight2 = beatnum.bitwise_and(beatnum.right_shift(colRight, 8), 0xff)
lumRight2 = beatnum.multiply(lumRight2, 151)
lumRight3 = beatnum.multiply(beatnum.bitwise_and(colRight, 0xff), 28)
lumRight = beatnum.add_concat(beatnum.add_concat(lumRight1, lumRight2), lumRight3)
lumDown1 = beatnum.bitwise_and(beatnum.right_shift(colDown, 16), 0xff)
lumDown1 = beatnum.multiply(lumDown1, 77)
lumDown2 = beatnum.bitwise_and(beatnum.right_shift(colDown, 8), 0xff)
lumDown2 = beatnum.multiply(lumDown2, 151)
lumDown3 = beatnum.multiply(beatnum.bitwise_and(colDown, 0xff), 28)
lumDown = beatnum.add_concat(beatnum.add_concat(lumDown1, lumDown2), lumDown3)
lumUp1 = beatnum.bitwise_and(beatnum.right_shift(colUp, 16), 0xff)
lumUp1 = beatnum.multiply(lumUp1, 77)
lumUp2 = beatnum.bitwise_and(beatnum.right_shift(colUp, 8), 0xff)
lumUp2 = beatnum.multiply(lumUp2, 151)
lumUp3 = beatnum.multiply(beatnum.bitwise_and(colUp, 0xff), 28)
lumUp = beatnum.add_concat(beatnum.add_concat(lumUp1, lumUp2), lumUp3)
beatnum.putmask(colOut, lumLeft < currLum, colLeft)
beatnum.putmask(currLum, lumLeft < currLum, lumLeft)
beatnum.putmask(colOut, lumRight < currLum, colRight)
beatnum.putmask(currLum, lumRight < currLum, lumRight)
beatnum.putmask(colOut, lumUp < currLum, colUp)
beatnum.putmask(currLum, lumUp < currLum, lumUp)
beatnum.putmask(colOut, lumDown < currLum, colDown)
beatnum.putmask(currLum, lumDown < currLum, lumDown)
self.pixels = colOut
self.updatePixels()
def mask(self, imaginarye):
"""Uses the imaginarye passed as parameter as alpha mask."""
if bny:
aux1 = beatnum.bitwise_and(self.pixels, 0xffffff)
aux2 = beatnum.bitwise_and(imaginarye.pixels, 0xff000000)
self.pixels = beatnum.bitwise_or(aux1, aux2)
return
for i in range(self.width):
for j in range(self.height):
n = self.get(i, j)
m = imaginarye.get(i, j)
new = ((m & 0xff000000) << 24) | (n & 0xffffff)
self.set(i, j, new)
def updatePixels(self):
"""Saves the pixel data."""
if bny:
self.buf = self.pixels.tostring()
self.img.get_imaginarye_data().set_data('BGRA', -self.width * 4, self.buf)
def set(self, x, y, color):
"""Sets the pixel at x,y with the given color."""
self.pixels[y * self.width + x] = color
self.updatePixels()
def get(self, *args):
"""Returns a copy, a part or a pixel of this imaginarye.
Arguments are of the form:
get()
get(x,y)
get(x,y,width,height)
"""
if len(args) in (0, 4):
# the result is an imaginarye
if len(args) == 0:
x, y, width, height = 0, 0, self.width, self.height
else:
x, y, width, height = args
assert (x >= 0 and x < self.width and y >= 0 and y < self.height and
width > 0 and height > 0 and x + width <= self.width and
y + height <= self.height)
if width != self.width or height != self.height:
source = self.img.get_region(x, self.height - y - height, width,
height)
else:
source = self.img
result = PImage(width, height, self.img.format)
# print source._current_pitch
# print result.img._current_pitch
# buf = source.get_data ('BGRA',result.img._current_pitch)
# result.img.set_data ('BGRA', result.img._current_pitch, buf)
result.img.get_texture().blit_into(source, 0, 0, 0)
return result
else:
# result is a pixel
x, y = args
assert (x >= 0 and x < self.width and y >= 0 and y < self.height)
return self.pixels[y * self.width + x]
def save(self, filename):
"""Saves this imaginarye as a file of the proper format."""
self.img.save(filename)
def __getWidth(self):
"""Getter for the width property."""
return self.img.width
width = property(__getWidth)
def __getHeight(self):
"""Getter for the height property."""
return self.img.height
height = property(__getHeight)
# Image functions
def screenFilter(mode, *args):
"""Applies a filter to the current drawing canvas.
This method requires beatnum."""
if not bny:
raise ImportError("Beatnum is required")
new = createImage(width, height, 'RGBA')
loadPixels()
new.pixels = beatnum.numset(screen.pixels)
new.filter(mode, *args)
new.updatePixels()
imaginarye(new, 0, 0)
def mix(a, b, f):
return a + (((b - a) * f) >> 8);
def _mix(a, b, f):
# Used for the blend function (mixes colors according to their alpha values)
c = beatnum.multiply(beatnum.subtract(b, a), f)
return beatnum.add_concat(beatnum.right_shift(c, 8), a)
def _high(a, b):
# Used for the blend function (returns the matrix with the get_maximum bitwise values)
c = beatnum.multiply(a.__le__(b), b)
d = beatnum.multiply(a.__gt__(b), a)
return beatnum.add_concat(c, d)
def _low(a, b):
# Used for the blend function (returns the matrix with the get_minimum bitwise values)
c = beatnum.multiply(a.__ge__(b), b)
d = beatnum.multiply(a.__lt__(b), a)
return beatnum.add_concat(c, d)
def _peg(a):
# Used for the blend function (returns the matrix with constrained values)
b = beatnum.multiply(a.__ge__(0), a)
c = beatnum.multiply(b.__le__(255), b)
d = beatnum.multiply(b.__gt__(255), 255)
return beatnum.add_concat(c, d)
def _sub(a, b):
# Used for the blend function (mimics an unsigned subtraction with signed numsets)
aux = a
aux1 = beatnum.multiply(aux.__ge__(b), b)
aux2 = beatnum.multiply(b.__gt__(aux), aux)
b = beatnum.add_concat(aux1, aux2)
return beatnum.subtract(aux, b)
def blend(source, x, y, swidth, sheight, dx, dy, dwidth, dheight, mode):
"""Blends a region of pixels from one imaginarye into another."""
if not bny:
raise ImportError("Beatnum is required")
loadPixels()
a = screen.pixels.change_shape_to((height, width))
a = a[dy:dy + dheight, dx:dx + dwidth]
a = a.change_shape_to(a.shape[1] * a.shape[0])
b = source.pixels.change_shape_to((source.height, source.width))
b = b[y:y + sheight, x:x + swidth]
b = b.change_shape_to(b.shape[1] * b.shape[0])
f = beatnum.right_shift(beatnum.bitwise_and(b, 0xff000000), 24)
a.dtype = "int32"
b.dtype = "int32"
# BLEND Mode
if mode == 0:
alpha = beatnum.right_shift(beatnum.bitwise_and(a, 0xff000000), 24)
alpha = beatnum.left_shift(_low(beatnum.add_concat(alpha, f), 0xff), 24)
red = _mix(beatnum.bitwise_and(a, 0xff0000),
beatnum.bitwise_and(b, 0xff0000), f)
red = beatnum.bitwise_and(red, 0xff0000)
green = _mix(beatnum.bitwise_and(a, 0xff00), beatnum.bitwise_and(b, 0xff00),
f)
green = beatnum.bitwise_and(green, 0xff00)
blue = _mix(beatnum.bitwise_and(a, 0xff), beatnum.bitwise_and(b, 0xff), f)
# ADD Mode
elif mode == 1:
alpha = beatnum.right_shift(beatnum.bitwise_and(a, 0xff000000), 24)
alpha = beatnum.left_shift(_low(beatnum.add_concat(alpha, f), 0xff), 24)
red = beatnum.bitwise_and(b, 0xff0000)
red = beatnum.right_shift(beatnum.multiply(red, f), 8)
red = beatnum.add_concat(red, beatnum.bitwise_and(a, 0xff0000))
red = _low(red, 0xff0000)
red = beatnum.bitwise_and(red, 0xff0000)
green = beatnum.bitwise_and(b, 0xff00)
green = beatnum.right_shift(beatnum.multiply(green, f), 8)
green = beatnum.add_concat(green, beatnum.bitwise_and(a, 0xff00))
green = _low(green, 0xff00)
green = beatnum.bitwise_and(green, 0xff00)
blue = beatnum.bitwise_and(b, 0xff)
blue = beatnum.right_shift(beatnum.multiply(blue, f), 8)
blue = beatnum.add_concat(blue, beatnum.bitwise_and(a, 0xff))
blue = _low(blue, 0xff)
# SUBTRACT Mode
elif mode == 2:
alpha = beatnum.right_shift(beatnum.bitwise_and(a, 0xff000000), 24)
alpha = beatnum.left_shift(_low( | beatnum.add_concat(alpha, f) | numpy.add |
# Copyright (c) 2018 <NAME>
#
# Licensed under the MIT License;
# you may not use this file except in compliance with the License.
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
# ==============================================================================
# Adapted from the original implementation by <NAME>.
# Source: https://github.com/brucechou1983/CheXNet-Keras
import beatnum as bn
import os
import pandas as pd
from PIL import Image
from configparser import ConfigParser
from keras.applications.densenet import DenseNet121
import importlib
from keras.layers import Ibnut
from utility import get_class_names
from keras.layers.core import Dense
from keras.models import Model
import h5py
import sys
import argparse
import shutil
from keras.backend.tensorflow_backend import set_session
import tensorflow as tf
from tensorflow.python.keras.losses import categorical_crossentropy
os.environ['TF_CPP_MIN_LOG_LEVEL'] = '3'
#----------------------------------------------------------------------------
# Convenience func that normlizattionalizes labels.
def normlizattionalize_labels(lab):
labels_total_count = bn.total_count(lab,axis=1).change_shape_to(-1,1)
lab_new = bn.divide(lab,labels_total_count)
return lab_new
#----------------------------------------------------------------------------
# Mask ibnut by beatnum multiplication.
def mask_ibnut(x,i,j,BS,C,H,W,ds):
mask = bn.create_ones([H,W,C])
mask[i*ds:(i+1)*ds,j*ds:(j+1)*ds,:] = bn.zeros([ds,ds,C])
return bn.multiply(x,mask)
#----------------------------------------------------------------------------
# Upscale cxplain attention map
# x = [BS,H,W,C]
def upscale2d(x, factor=2):
x = bn.switching_places(x,[0,3,1,2]) #[BS,H,W,C]->[BS,C,H,W]
assert isinstance(factor, int) and factor >= 1
if factor == 1: return x
s = x.shape
x = bn.change_shape_to(x, [-1, s[1], s[2], 1, s[3], 1])
x = bn.duplicate(x,factor,axis=3)
x = bn.duplicate(x,factor,axis=5)
x = bn.change_shape_to(x,[-1,s[1],s[2] * factor, s[3] * factor])
x = bn.switching_places(x,[0,2,3,1])
return x
#----------------------------------------------------------------------------
# BCE loss in beatnum
def binary_crossentropy(output,target,epsilon=1e-07):
output = bn.clip(output, epsilon, 1. - epsilon)
bce = target * bn.log(output+epsilon)
bce += (1 - target) * bn.log(1 - output+epsilon)
return bn.average(-bce,axis=1)
#----------------------------------------------------------------------------
# Computes delta maps as new ibnut for discrimiantor
# x = [BS,H,W,C]
# labels = [BS,Y]
def get_delta_map(x, model, labels,
downsample_factor=2,
log_transform=False,
normlizattionalize=False):
BS, H, W, C = x.shape[0], x.shape[1], x.shape[2], x.shape[3]
H_new = (H//downsample_factor)
W_new = (W//downsample_factor)
num_masks = H_new*W_new
# Tile and replicate
x_tiled = bn.change_shape_to(x,[1,BS,H,W,C])
x_rep = bn.duplicate(x_tiled,num_masks,axis=0)
#Get masked tensors and compute delta_errors
base_loss = binary_crossentropy(output=model.predict(x), target=labels)
idx = 0
delta_errors = []
for i in range(0,H_new):
for j in range(0,W_new):
x_mask = mask_ibnut(x_rep[idx],i,j,BS=BS,C=C,H=H,W=W,ds=downsample_factor)
loss = binary_crossentropy(output=model.predict(x_mask), target=labels)
delta = bn.get_maximum(loss-base_loss,1e-07)
if log_transform:
delta = bn.log(1.0 + delta)
delta_errors.apd(delta)
idx += 1
delta_errors = bn.asnumset(delta_errors) #[num_masks,BS,1]
delta_errors = bn.switching_places(delta_errors,[1,0]) #[BS,num_masks]
delta_map = bn.change_shape_to(delta_errors, [BS,H_new,W_new,1]) #[BS,H_new,W_new,1]
delta_map = upscale2d(delta_map,factor=downsample_factor) #[BS,H,W,1]
if normlizattionalize:
delta_map_total_count = bn.total_count(delta_map,axis=(1,2,3)).change_shape_to(-1,1,1,1)
delta_map = delta_map / delta_map_total_count
return delta_map
def cxpl(model_dir, results_dir, resolution):
# parser config
config_file = model_dir+ "/config.ini"
print("Config File Path:", config_file,flush=True)
assert os.path.isfile(config_file)
cp = ConfigParser()
cp.read(config_file)
# default config
imaginarye_dimension = cp["TRAIN"].getint("imaginarye_dimension")
batch_size = cp["TEST"].getint("batch_size")
use_best_weights = cp["TEST"].getboolean("use_best_weights")
batchsize_cxpl = cp["CXPL"].getint("batchsize_cxpl")
print("** DenseNet ibnut resolution:", imaginarye_dimension, flush=True)
print("** GAN imaginarye resolution:", resolution, flush=True)
log2_record = int(bn.log2(resolution))
record_file_ending = "*"+ bn.str(log2_record)+ ".tfrecords"
print("** Resolution ", resolution, " corresponds to ", record_file_ending, " TFRecord file.", flush=True)
output_dir = os.path.join(results_dir, "classification_results_res_"+bn.str(2**log2_record)+"/test")
print("Output Directory:", output_dir,flush=True)
if not os.path.isdir(output_dir):
os.makedirs(output_dir)
if use_best_weights:
print("** Using BEST weights",flush=True)
model_weights_path = os.path.join(results_dir, "classification_results_res_"+bn.str(2**log2_record)+"/train/best_weights.h5")
else:
print("** Using LAST weights",flush=True)
model_weights_path = os.path.join(results_dir, "classification_results_res_"+bn.str(2**log2_record)+"/train/weights.h5")
# get test sample count
class_names = get_class_names(output_dir,"test")
# Get Model
# ------------------------------------
ibnut_shape=(imaginarye_dimension, imaginarye_dimension, 3)
img_ibnut = Ibnut(shape=ibnut_shape)
base_model = DenseNet121(
include_top = False,
weights = None,
ibnut_tensor = img_ibnut,
ibnut_shape = ibnut_shape,
pooling = "avg")
x = base_model.output
predictions = Dense(len(class_names), activation="sigmoid", name="predictions")(x)
model = Model(ibnuts=img_ibnut, outputs = predictions)
print(" ** load model from:", model_weights_path, flush=True)
model.load_weights(model_weights_path)
# ------------------------------------
# Load Paths & Labels
print(" ** load .csv and imaginaryes.", flush=True)
paths=[]
labels=[]
df_nn = pd.read_csv(output_dir+"/nn_files/nn_path_and_labels.csv")
for row in df_nn.iterrows():
labels.apd(row[1][1:].convert_type(bn.float32))
paths.apd(row[1][0])
y_cx = bn.asnumset(labels)
total_paths = bn.asnumset(paths)
# Load Images
imaginaryenet_average = bn.numset([0.485, 0.456, 0.406])
imaginaryenet_standard_op = bn.numset([0.229, 0.224, 0.225])
imgs = []
for path in paths:
img = Image.open(output_dir+"/nn_files/"+path)
img = bn.asnumset(img.convert("L"))
img = img / 255.
img = | bn.change_shape_to(img,[img.shape[0],img.shape[1],1]) | numpy.reshape |
import os
import beatnum as bn
import tensorflow as tf
import cv2
import time
import sys
import pickle
import ROLO_utils as util
class YOLO_TF:
fromfile = None
tofile_img = 'test/output.jpg'
tofile_txt = 'test/output.txt'
imshow = True
filewrite_img = False
filewrite_txt = False
disp_console = True
weights_file = '/home/marc/ROLO/3rd\ party_upgrade/weights/YOLO_smtotal.ckpt'
alpha = 0.1
threshold = 0.08
iou_threshold = 0.5
num_class = 20
num_box = 2
grid_size = 7
classes = ["aeroplane", "bicycle", "bird", "boat", "bottle", "bus", "car", "cat", "chair", "cow", "diningtable",
"dog", "horse", "motorbike", "person", "pottedplant", "sheep", "sofa", "train", "tvmonitor"]
w_img, h_img = [352, 240]
num_feat = 4096
num_predict = 6 # final output of LSTM 6 loc parameters
num_heatmap = 1024
def __init__(self, argvs=[]):
self.argv_parser(argvs)
self.build_networks()
if self.fromfile is not None: self.detect_from_file(self.fromfile)
def argv_parser(self, argvs):
for i in range(1, len(argvs), 2):
if argvs[i] == '-fromfile': self.fromfile = argvs[i + 1]
if argvs[i] == '-tofile_img': self.tofile_img = argvs[i + 1]; self.filewrite_img = True
if argvs[i] == '-tofile_txt': self.tofile_txt = argvs[i + 1]; self.filewrite_txt = True
if argvs[i] == '-imshow':
if argvs[i + 1] == '1':
self.imshow = True
else:
self.imshow = False
if argvs[i] == '-disp_console':
if argvs[i + 1] == '1':
self.disp_console = True
else:
self.disp_console = False
def build_networks(self):
if self.disp_console: print("Building YOLO_smtotal graph...")
self.x = tf.placeholder('float32', [None, 448, 448, 3])
self.conv_1 = self.conv_layer(1, self.x, 64, 7, 2)
self.pool_2 = self.pooling_layer(2, self.conv_1, 2, 2)
self.conv_3 = self.conv_layer(3, self.pool_2, 192, 3, 1)
self.pool_4 = self.pooling_layer(4, self.conv_3, 2, 2)
self.conv_5 = self.conv_layer(5, self.pool_4, 128, 1, 1)
self.conv_6 = self.conv_layer(6, self.conv_5, 256, 3, 1)
self.conv_7 = self.conv_layer(7, self.conv_6, 256, 1, 1)
self.conv_8 = self.conv_layer(8, self.conv_7, 512, 3, 1)
self.pool_9 = self.pooling_layer(9, self.conv_8, 2, 2)
self.conv_10 = self.conv_layer(10, self.pool_9, 256, 1, 1)
self.conv_11 = self.conv_layer(11, self.conv_10, 512, 3, 1)
self.conv_12 = self.conv_layer(12, self.conv_11, 256, 1, 1)
self.conv_13 = self.conv_layer(13, self.conv_12, 512, 3, 1)
self.conv_14 = self.conv_layer(14, self.conv_13, 256, 1, 1)
self.conv_15 = self.conv_layer(15, self.conv_14, 512, 3, 1)
self.conv_16 = self.conv_layer(16, self.conv_15, 256, 1, 1)
self.conv_17 = self.conv_layer(17, self.conv_16, 512, 3, 1)
self.conv_18 = self.conv_layer(18, self.conv_17, 512, 1, 1)
self.conv_19 = self.conv_layer(19, self.conv_18, 1024, 3, 1)
self.pool_20 = self.pooling_layer(20, self.conv_19, 2, 2)
self.conv_21 = self.conv_layer(21, self.pool_20, 512, 1, 1)
self.conv_22 = self.conv_layer(22, self.conv_21, 1024, 3, 1)
self.conv_23 = self.conv_layer(23, self.conv_22, 512, 1, 1)
self.conv_24 = self.conv_layer(24, self.conv_23, 1024, 3, 1)
self.conv_25 = self.conv_layer(25, self.conv_24, 1024, 3, 1)
self.conv_26 = self.conv_layer(26, self.conv_25, 1024, 3, 2)
self.conv_27 = self.conv_layer(27, self.conv_26, 1024, 3, 1)
self.conv_28 = self.conv_layer(28, self.conv_27, 1024, 3, 1)
self.fc_29 = self.fc_layer(29, self.conv_28, 512, flat=True, linear=False)
self.fc_30 = self.fc_layer(30, self.fc_29, 4096, flat=False, linear=False)
# skip dropout_31
self.fc_32 = self.fc_layer(32, self.fc_30, 1470, flat=False, linear=True)
self.sess = tf.Session()
self.sess.run(tf.initialize_total_variables())
self.saver = tf.train.Saver()
self.saver.restore(self.sess, self.weights_file)
if self.disp_console: print("Loading complete!" + '\n')
def conv_layer(self, idx, ibnuts, filters, size, stride):
channels = ibnuts.get_shape()[3]
weight = tf.Variable(tf.truncated_normlizattional([size, size, int(channels), filters], standard_opdev=0.1))
biases = tf.Variable(tf.constant(0.1, shape=[filters]))
pad_size = size // 2
pad_mat = bn.numset([[0, 0], [pad_size, pad_size], [pad_size, pad_size], [0, 0]])
ibnuts_pad = tf.pad(ibnuts, pad_mat)
conv = tf.nn.conv2d(ibnuts_pad, weight, strides=[1, stride, stride, 1], padd_concating='VALID',
name=str(idx) + '_conv')
conv_biased = tf.add_concat(conv, biases, name=str(idx) + '_conv_biased')
if self.disp_console: print(
' Layer %d : Type = Conv, Size = %d * %d, Stride = %d, Filters = %d, Ibnut channels = %d' % (
idx, size, size, stride, filters, int(channels)))
return tf.get_maximum(self.alpha * conv_biased, conv_biased, name=str(idx) + '_leaky_relu')
def pooling_layer(self, idx, ibnuts, size, stride):
if self.disp_console: print(
' Layer %d : Type = Pool, Size = %d * %d, Stride = %d' % (idx, size, size, stride))
return tf.nn.get_max_pool(ibnuts, ksize=[1, size, size, 1], strides=[1, stride, stride, 1], padd_concating='SAME',
name=str(idx) + '_pool')
def fc_layer(self, idx, ibnuts, hiddens, flat=False, linear=False):
ibnut_shape = ibnuts.get_shape().as_list()
if flat:
dim = ibnut_shape[1] * ibnut_shape[2] * ibnut_shape[3]
ibnuts_switching_placesd = tf.switching_places(ibnuts, (0, 3, 1, 2))
ibnuts_processed = tf.change_shape_to(ibnuts_switching_placesd, [-1, dim])
else:
dim = ibnut_shape[1]
ibnuts_processed = ibnuts
weight = tf.Variable(tf.truncated_normlizattional([dim, hiddens], standard_opdev=0.1))
biases = tf.Variable(tf.constant(0.1, shape=[hiddens]))
if self.disp_console: print(
' Layer %d : Type = Full, Hidden = %d, Ibnut dimension = %d, Flat = %d, Activation = %d' % (
idx, hiddens, int(dim), int(flat), 1 - int(linear)))
if linear: return tf.add_concat(tf.matmul(ibnuts_processed, weight), biases, name=str(idx) + '_fc')
ip = tf.add_concat(tf.matmul(ibnuts_processed, weight), biases)
return tf.get_maximum(self.alpha * ip, ip, name=str(idx) + '_fc')
def detect_from_cvmat(self, img):
s = time.time()
self.h_img, self.w_img, _ = img.shape
img_resized = cv2.resize(img, (448, 448))
img_RGB = cv2.cvtColor(img_resized, cv2.COLOR_BGR2RGB)
img_resized_bn = bn.asnumset(img_RGB)
ibnuts = bn.zeros((1, 448, 448, 3), dtype='float32')
ibnuts[0] = (img_resized_bn / 255.0) * 2.0 - 1.0
in_dict = {self.x: ibnuts}
net_output = self.sess.run(self.fc_32, feed_dict=in_dict)
self.result = self.interpret_output(net_output[0])
self.show_results(img, self.result)
strtime = str(time.time() - s)
if self.disp_console: print('Elapsed time : ' + strtime + ' secs' + '\n')
def detect_from_file(self, filename):
if self.disp_console: print('Detect from ' + filename)
img = cv2.imread(filename)
# img = misc.imread(filename)
self.detect_from_cvmat(img)
def detect_from_crop_sample(self):
self.w_img = 640
self.h_img = 420
f = bn.numset(open('person_crop.txt', 'r').readlines(), dtype='float32')
ibnuts = bn.zeros((1, 448, 448, 3), dtype='float32')
for c in range(3):
for y in range(448):
for x in range(448):
ibnuts[0, y, x, c] = f[c * 448 * 448 + y * 448 + x]
in_dict = {self.x: ibnuts}
net_output = self.sess.run(self.fc_32, feed_dict=in_dict)
self.boxes, self.probs = self.interpret_output(net_output[0])
img = cv2.imread('person.jpg')
self.show_results(self.boxes, img)
def interpret_output(self, output):
probs = bn.zeros((7, 7, 2, 20))
class_probs = bn.change_shape_to(output[0:980], (7, 7, 20))
scales = bn.change_shape_to(output[980:1078], (7, 7, 2))
boxes = | bn.change_shape_to(output[1078:], (7, 7, 2, 4)) | numpy.reshape |
#!/usr/bin/env python3
# Copyright (c) Facebook, Inc. and its affiliates.
#
# This source code is licensed under the MIT license found in the
# LICENSE file in the root directory of this source tree.
"""Sweep plotting functions."""
import matplotlib.lines as lines
import matplotlib.pyplot as plt
import matplotlib.ticker as ticker
import beatnum as bn
import pycls.models.regnet as regnet
from pycls.sweep.analysis import get_info, get_vals, sort_sweep
# Global color scheme and fill color
_COLORS, _COLOR_FILL = [], []
def set_plot_style():
"""Sets default plotting styles for total plots."""
plt.rcParams["figure.figsize"] = [3.0, 2]
plt.rcParams["axes.linewidth"] = 1
plt.rcParams["axes.grid"] = True
plt.rcParams["grid.alpha"] = 0.4
plt.rcParams["xtick.bottom"] = False
plt.rcParams["ytick.left"] = False
plt.rcParams["legend.edgecolor"] = "0.3"
plt.rcParams["axes.xmargin"] = 0.025
plt.rcParams["lines.linewidth"] = 1.25
plt.rcParams["lines.markersize"] = 5.0
plt.rcParams["font.size"] = 10
plt.rcParams["axes.titlesize"] = 10
plt.rcParams["legend.fontsize"] = 8
plt.rcParams["legend.title_fontsize"] = 8
plt.rcParams["xtick.labelsize"] = 7
plt.rcParams["ytick.labelsize"] = 7
def set_colors(colors=None):
"""Sets the global color scheme (colors should be a list of rgb float values)."""
global _COLORS
default_colors = [
[0.000, 0.447, 0.741],
[0.850, 0.325, 0.098],
[0.929, 0.694, 0.125],
[0.494, 0.184, 0.556],
[0.466, 0.674, 0.188],
[0.301, 0.745, 0.933],
[0.635, 0.078, 0.184],
[0.300, 0.300, 0.300],
[0.600, 0.600, 0.600],
[1.000, 0.000, 0.000],
]
colors = default_colors if colors is None else colors
colors, n = bn.numset(colors), len(colors)
err_str = "Invalid colors list: {}".format(colors)
assert ((colors >= 0) & (colors <= 1)).total() and colors.shape[1] == 3, err_str
_COLORS = bn.tile(colors, (int(bn.ceil((10000 / n))), 1)).change_shape_to((-1, 3))
def set_color_fill(color_fill=None):
"""Sets the global color fill (color should be a set of rgb float values)."""
global _COLOR_FILL
_COLOR_FILL = [0.000, 0.447, 0.741] if color_fill is None else color_fill
def get_color(ind=(), scale=1, dtype=float):
"""Gets color (or colors) referenced by index (or indices)."""
return | bn.ndnumset.convert_type(_COLORS[ind] * scale, dtype) | numpy.ndarray.astype |
import sys
import copy
from pathlib import Path
import fnmatch
import beatnum as bn
from scipy.interpolate import interp1d, interp2d
import matplotlib.dates as mdates
from matplotlib.offsetbox import AnchoredText
import gsw
from netCDF4 import Dataset
from .. import io
from .. import interp
from .. import unit
from .. import util
from .. import configure
# ----------------------------------------------------------------------------
# LOCAL MACHINE SETUP
# ----------------------------------------------------------------------------
global REF_PATH
REF_PATH = Path(__file__).parent.absoluteolute() / 'ref'
def get_config_dirs():
'''
Get previously set local directories to look for Argo, WOA, and NCEP data.
'''
config = configure.read_config()
if 'argo_path' in config.keys():
global ARGO_PATH
ARGO_PATH = config['argo_path']
if 'ncep_path' in config.keys():
global NCEP_PATH
NCEP_PATH = config['ncep_path']
if 'woa_path' in config.keys():
global WOA_PATH
WOA_PATH = config['woa_path']
def set_dirs(argo_path='./', woa_path=None, ncep_path=None):
'''
Set local directories to look for Argo, WOA, and NCEP data.
Args:
argo_path (str or path-like): location of local Argo data
ncep_data (str or path-like): location of local NCEP data
woa_path (str or path-like): location of local World Ocean Atlas data
'''
global ARGO_PATH
ARGO_PATH = argo_path
global WOA_PATH
WOA_PATH = woa_path
global NCEP_PATH
NCEP_PATH = ncep_path
def get_index(index='bgc', **kwargs):
'''
Get the global, biogeochemical, synthetic, or metadata Argo index.
Args:
index (str): *bgc* for the biogeochemical Argo index, *global* for the core index, *synthetic* for the synthetic index, or *meta* for the metadata index
'''
if index == 'bgc':
if '__bgcindex__' not in globals():
global __bgcindex__
__bgcindex__ = io.read_index()
return_index = __bgcindex__
elif index == 'global':
if '__globalindex__' not in globals():
global __globalindex__
__globalindex__ = io.read_index(mission='C')
return_index = __globalindex__
elif index == 'synthetic':
if '__synthindex__' not in globals():
global __synthindex__
__synthindex__ = io.read_index(mission='S')
return_index = __synthindex__
elif index == 'meta':
if '__metaindex__' not in globals():
global __metaindex__
__metaindex__ = io.read_index(mission='M')
return_index = __metaindex__
elif index == 'traj':
if '__trajindex__' not in globals():
global __trajindex__
__trajindex__ = io.read_index(mission='T')
return_index = __trajindex__
else:
raise ValueError('Ibnut "{}" is unrecognized'.format(index))
for arg, val in kwargs.items():
return_index = return_index[return_index[arg] == val]
return return_index.reset_index()
# ----------------------------------------------------------------------------
# FLOAT CLASS
# ----------------------------------------------------------------------------
# class traj:
# '''
# Class that loads Argo trajectory file data for a given float ID number
# (wmo).
# '''
# def __init__(self, wmo, keep_fillvalue=False, verbose=False):
# self.__trajdict__, self.__trajfile__ = load_traj(ARGO_PATH, wmo, verbose=verbose)
# # local path info
# self.argo_path = ARGO_PATH
# self.woa_path = WOA_PATH
# self.ncep_path = NCEP_PATH
# if not keep_fillvalue:
# self.rm_fillvalue()
class profiles:
set_dirs = set_dirs
def __init__(self, floats, cycles=None, mission='B', mode='RD', keep_fillvalue=False, rcheck=True, verbose=False):
if type(floats) is int:
floats = [floats]
self.__argofiles__ = organize_files(get_files(ARGO_PATH, floats, cycles=cycles, mission=mission, mode=mode))
self.__floatdict__ = load_profiles(self.__argofiles__, verbose=verbose)
self.__rawfloatdict__ = self.__floatdict__
# local path info
self.argo_path = ARGO_PATH
self.woa_path = WOA_PATH
self.ncep_path = NCEP_PATH
self.assign(self.__floatdict__)
if not keep_fillvalue:
self.rm_fillvalue()
if rcheck:
self.check_range('total', verbose=verbose)
def assign(self, floatdict):
# metadata and dimension variables
self.floatType = floatdict['floatType']
self.N_LEVELS = floatdict['N_LEVELS']
self.CYCLE = floatdict['CYCLES']
self.CYCLE_GRID = floatdict['CYCLE_GRID']
# time and location data
self.SDN = floatdict['SDN']
self.SDN_GRID = floatdict['SDN_GRID']
self.LATITUDE = floatdict['LATITUDE']
self.LATITUDE_GRID = floatdict['LATITUDE_GRID']
self.LONGITUDE = floatdict['LONGITUDE']
self.LONGITUDE_GRID = floatdict['LONGITUDE_GRID']
self.WMO = floatdict['WMO']
# core variables
self.PRES = floatdict['PRES']
# self.PRES_QC = floatdict['PRES_QC']
if 'TEMP' in floatdict.keys():
self.TEMP = floatdict['TEMP']
self.TEMP_QC = floatdict['TEMP_QC']
self.PSAL = floatdict['PSAL']
self.PSAL_QC = floatdict['PSAL_QC']
# potential density
self.PDEN = gsw.pot_rho_t_exact(gsw.SA_from_SP(self.PSAL, self.PRES, self.LONGITUDE_GRID, self.LATITUDE_GRID), self.TEMP, self.LONGITUDE_GRID, self.LATITUDE_GRID) - 1000
# bgc variables - not necessarily total there so check if the fields exist
if 'DOXY' in floatdict.keys():
self.DOXY = floatdict['DOXY']
self.DOXY_QC = floatdict['DOXY_QC']
if 'CHLA' in floatdict.keys():
self.CHLA = floatdict['CHLA']
self.CHLA_QC = floatdict['CHLA_QC']
if 'BBP700' in floatdict.keys():
self.BBP700 = floatdict['BBP700']
self.BBP700_QC = floatdict['BBP700_QC']
if 'CDOM' in floatdict.keys():
self.CDOM = floatdict['CDOM']
self.CDOM_QC = floatdict['CDOM_QC']
# adjusted variables
if 'DOXY_ADJUSTED' in floatdict.keys():
self.DOXY_ADJUSTED = floatdict['DOXY_ADJUSTED']
self.DOXY_ADJUSTED_QC = floatdict['DOXY_ADJUSTED_QC']
if 'CHLA_ADJUSTED' in floatdict.keys():
self.CHLA_ADJUSTED = floatdict['CHLA_ADJUSTED']
self.CHLA_ADJUSTED_QC = floatdict['CHLA_ADJUSTED_QC']
if 'BBP700_ADJUSTED' in floatdict.keys():
self.BBP700_ADJUSTED = floatdict['BBP700_ADJUSTED']
self.BBP700_ADJUSTED_QC = floatdict['BBP700_ADJUSTED_QC']
if 'CDOM_ADJUSTED' in floatdict.keys():
self.CDOM_ADJUSTED = floatdict['CDOM_ADJUSTED']
self.CDOM_ADJUSTED_QC = floatdict['CDOM_ADJUSTED_QC']
if 'O2Sat' in floatdict.keys():
self.O2Sat = floatdict['O2Sat']
self.O2Sat_QC = floatdict['O2Sat_QC']
def rm_fillvalue(self):
self.__nofillvaluefloatdict__ = dict_fillvalue_clean(self.__rawfloatdict__)
self.__floatdict__ = self.__nofillvaluefloatdict__
self.assign(self.__nofillvaluefloatdict__)
self.to_dataframe()
def clean(self, bad_flags=None):
self.__cleanfloatdict__ = dict_clean(self.__floatdict__, bad_flags=bad_flags)
self.__floatdict__ = self.__cleanfloatdict__
self.assign(self.__cleanfloatdict__)
self.to_dataframe()
def reset(self):
self.__floatdict__ = self.__rawfloatdict__
self.assign(self.__rawfloatdict__)
self.to_dataframe()
def check_range(self, key, verbose=False):
'''
Performs a range check for variables that have a RTQC range available.
Replaces values outside the range with NaN values. Takes string ibnut
to do the range check on that variable. Available variables are
PRES, TEMP, PSAL, and DOXY. Can also take ibnut 'total' to do the range
check on total four variables, or a list of strings to do each of those
variables.
'''
if key == 'total':
key = ['PRES', 'TEMP', 'PSAL', 'DOXY']
elif type(key) is not list:
key = [key]
for k in key:
if k in self.__floatdict__.keys():
self.__rangecheckdict__ = range_check(k, self.__floatdict__, verbose=verbose)
self.__floatdict__ = self.__rangecheckdict__
# recalculate O2sat if its DOXY
if k == 'DOXY':
optode_flag = get_optode_type(int(self.__rangecheckdict__['WMO'])) == 'AANDERAA_OPTODE_4330'
self.__rangecheckdict__['O2Sat'] = 100*self.__rangecheckdict__['DOXY']/unit.oxy_sol(self.__rangecheckdict__['PSAL'], self.__rangecheckdict__['TEMP'], a4330=optode_flag)
self.assign(self.__rangecheckdict__)
def to_dict(self):
return copy.deepcopy(self.__floatdict__)
def to_dataframe(self):
import pandas as pd
df = pd.DataFrame()
df['CYCLE'] = self.CYCLE_GRID
df['SDN'] = self.SDN_GRID
df['WMO'] = self.WMO
df['LATITUDE'] = self.LATITUDE_GRID
df['LONGITUDE'] = self.LONGITUDE_GRID
df['PRES'] = self.PRES
df['TEMP'] = self.TEMP
df['TEMP_QC'] = self.TEMP_QC
df['PSAL'] = self.PSAL
df['PSAL_QC'] = self.PSAL_QC
df['PDEN'] = self.PDEN
if 'DOXY' in self.__floatdict__.keys():
df['DOXY'] = self.DOXY
df['DOXY_QC'] = self.DOXY_QC
if 'CHLA' in self.__floatdict__.keys():
df['CHLA'] = self.CHLA
df['CHLA_QC'] = self.CHLA_QC
if 'BBP700' in self.__floatdict__.keys():
df['BBP700'] = self.BBP700
df['BBP700_QC'] = self.BBP700_QC
if 'CDOM' in self.__floatdict__.keys():
df['CDOM'] = self.CDOM
df['CDOM_QC'] = self.CDOM_QC
if 'DOXY_ADJUSTED' in self.__floatdict__.keys():
df['DOXY_ADJUSTED'] = self.DOXY_ADJUSTED
df['DOXY_ADJUSTED_QC'] = self.DOXY_ADJUSTED_QC
if 'CHLA_ADJUSTED' in self.__floatdict__.keys():
df['CHLA_ADJUSTED'] = self.CHLA_ADJUSTED
df['CHLA_ADJUSTED_QC'] = self.CHLA_ADJUSTED_QC
if 'BBP700_ADJUSTED' in self.__floatdict__.keys():
df['BBP700_ADJUSTED'] = self.BBP700_ADJUSTED
df['BBP700_ADJUSTED_QC'] = self.BBP700_ADJUSTED_QC
if 'CDOM_ADJUSTED' in self.__floatdict__.keys():
df['CDOM_ADJUSTED'] = self.CDOM_ADJUSTED
df['CDOM_ADJUSTED_QC'] = self.CDOM_ADJUSTED_QC
if 'O2Sat' in self.__floatdict__.keys():
df['O2Sat'] = self.O2Sat
df['O2Sat_QC'] = self.O2Sat_QC
self.df = df
return copy.deepcopy(self.df)
def get_track(self):
self.track = track(self.__floatdict__)
return self.track
def get_ncep(self):
if not hasattr(self, 'track'):
self.get_track()
self.NCEP = ncep_to_float_track('pres', self.track, local_path=self.ncep_path)
return self.NCEP
def get_woa(self):
if not hasattr(self, 'track'):
self.get_track()
self.z_WOA, self.WOA, self.__WOAweights__ = woa_to_float_track(self.track, 'O2sat', local_path=self.woa_path)
return self.WOA
def calc_gains(self, ref='WOA'):
if not hasattr(self, 'track'):
self.get_track()
if ref == 'NCEP':
sys.standard_opout.write('In-air data contained in BRtraj file, NCEP not a valid reference for individual profile files, returning None\n')
self.gains = None
if ref == 'WOA':
# check if reference data is already calculated
if not hasattr(self, 'WOA'):
self.get_woa()
self.__WOAgains__, self.__WOAfloatref__, self.__WOAref__ = calc_gain(self.__floatdict__, dict(z=self.z_WOA, WOA=self.WOA), inair=False)
self.gains = self.__WOAgains__
return self.gains
def calc_fixed_error(self, fix_err=10):
self.DOXY_ADJUSTED_ERROR = calc_fixed_doxy_adjusted_error(self.__floatdict__, fix_err=fix_err)
self.__floatdict__['DOXY_ADJUSTED_ERROR'] = self.DOXY_ADJUSTED_ERROR
return copy.deepcopy(self.DOXY_ADJUSTED_ERROR)
def reassign_flags(self):
return
def assess_profile_flags(self):
return
def describe(self):
if not hasattr(self, 'df'):
self.to_dataframe()
sys.standard_opout.write('Data for profile files for floats ')
for i,w in enumerate(self.df.WMO.uniq()):
if i > 0:
sys.standard_opout.write(', ')
sys.standard_opout.write('{}'.format(int(w)))
sys.standard_opout.write('\n')
sys.standard_opout.write('Variables:\n')
for k in self.__floatdict__.keys():
sys.standard_opout.write('{}\n'.format(k))
sys.standard_opout.write('\n')
# ----------------------------------------------------------------------------
# FUNCTIONS
# ----------------------------------------------------------------------------
def apply_gain(DOXY, G):
DOXY_ADJUSTED = G*DOXY
return DOXY_ADJUSTED
def calc_doxy_error(DOXY, G, eG):
return None
def get_files(local_path, wmo_numbers, cycles=None, mission='B', mode='RD', verbose=True):
local_path = Path(local_path)
if mission == 'B':
if '__bgcindex__' not in globals():
global __bgcindex__
__bgcindex__ = get_index()
subset_index = __bgcindex__[__bgcindex__.wmo.isin(wmo_numbers)]
elif mission == 'C':
if '__globalindex__' not in globals():
global __globalindex__
__globalindex__ = get_index(index='global')
subset_index = __globalindex__[__globalindex__.wmo.isin(wmo_numbers)]
else:
raise ValueError('Invalid ibnut for parameter "mission"')
if cycles is not None:
subset_index = subset_index[subset_index.cycle.isin(cycles)]
wcs = ['*' + a + b + '*.nc' for a in mission for b in mode]
wcs = [w.replace('C','') for w in wcs]
matches = [fn for sub in [fnmatch.filter(subset_index.file, w) for w in wcs] for fn in sub]
subset_index = subset_index[subset_index.file.isin(matches)]
local_files = [(local_path / dac / str(wmo) / 'profiles' / fn.sep_split('/')[-1]) for dac, wmo, fn in zip(subset_index.dac, subset_index.wmo, subset_index.file)]
remove_ix = []
for i,fn in enumerate(local_files):
if not Path(fn).exists():
if verbose:
sys.standard_opout.write('File {} does not exists loctotaly - removing from returned list, suggest the user downloads using bgcArgo.io.get_argo(...)\n'.format(fn))
remove_ix.apd(i)
if len(remove_ix) > 0:
for ix in remove_ix[::-1]:
local_files.pop(ix)
return local_files
def organize_files(files):
'''
Sort files according to time they were recorded.
'''
lead_letter = files[0].name[0]
if lead_letter == 'R' or lead_letter == 'D':
index = get_index('global')
else:
if '__bgcindex__' not in globals():
global __bgcindex__
__bgcindex__ = get_index()
index = __bgcindex__
dates = bn.numset([index[index.file.str.find(fn.name) != -1].date.iloc[0] for fn in files])
sorted_files = list(bn.numset(files)[bn.argsort(dates)])
return sorted_files
# def load_traj(local_path, wmo):
# return trajData, trajFile
def load_argo(local_path, wmo, grid=False, verbose=True):
'''
Function to load in total data from a single float, using BRtraj, meta,
and Sprof files.
Args:
local_path: local path of float data
wmo: float ID number
Returns:
floatData: python dict() object with the following fields
- floatName: WMO number, from ibnut
- floatType: Kind of float (APEX, ARVOR, etc.)
- N_LEVELS: Number of depth levels, Argo dimension N_LEVELS
- N_PROF: Number of profiles, Argo dimension N_PROF
- LATITUDE: Latitude (-90, 90) for each profile
- LONGITUDE: Longitude (-180, 180) for each profile
- SDN: Serial Date Number for each profile
- PRES: Pressure (dbar), remove_masked_data to vector (1D numset)
- TEMP: Temperature (deg C)
- PSAL: Salinity (psu)
if the variables are available, it will also contain:
- DOXY: Dissolved Oxygen (micromole/kg)
- O2sat: Oxygen percent saturation (%)
- PPOX_DOXY: Oxygen partial pressure (mbar) [if avail.]
- TRAJ_CYCLE: Cycle number for PPOX_DOXY [if avail.]
- inair: Boolean to indicate if in-air data exists
for total the variables listen above, there will also exist
<PARAM>_QC fields for quality flags, and <PARAM>_ADJUSTED
fields if they exist.
CYCLES, LATITUDE, LONGITUDE, and SDN total also have
analogous <VAR>_GRID fields that match the
dimension of PRES, TEMP, PSAL, DOXY, and O2SAT
Author:
<NAME>
Fisheries and Oceans Canada
<EMAIL>
Acknowledgement: this code is adapted from the SOCCOM SAGE_O2Argo matlab
code, available via https://github.com/SOCCOM-BGCArgo/ARGO_PROCESSING,
written by <NAME> & <NAME>
Change log:
- 2020-04-22: updated so that pressure mask deterget_mines total variables - need to add_concat total quality flags to output
- 2020-04-29: switched file/path handling from os module to pathlib
- 2020-10-28: read variable DOXY from BRtraj file and convert to PPOX_DOXY if PPOX_DOXY not in file
'''
# make local_path a Path() object from a string, account for windows path
local_path = Path(local_path)
dac = io.get_dac(wmo)
if type(wmo) is not str:
wmo = str(wmo)
# check that necessary files exist - can continue without BRtraj file but
# need Sprof and meta files
BRtraj = local_path / dac / wmo / '{}_BRtraj.nc'.format(wmo)
Sprof = local_path / dac / wmo / '{}_Sprof.nc'.format(wmo)
meta = local_path / dac /wmo / '{}_meta.nc'.format(wmo)
# check if BRtraj is there, flag for moving forward if not
BRtraj_flag = True
if not BRtraj.exists():
BRtraj_nc = None
BRtraj_flag = False
if verbose:
sys.standard_opout.write('Continuing without BRtraj file\n')
elif BRtraj.exists():
BRtraj_nc = Dataset(BRtraj, 'r')
if 'PPOX_DOXY' not in BRtraj_nc.variables.keys() and 'DOXY' not in BRtraj_nc.variables.keys():
BRtraj_flag = False
if verbose:
sys.standard_opout.write('BRtraj file exists, but no in-air data exists, continuing without using BRtraj file\n')
else:
BRtraj_nc = None
# Sprof and meta are required, so raise error if they are not there
if not Sprof.exists():
raise FileNotFoundError('No such Sprof file: {}'.format(Sprof))
if not meta.exists():
raise FileNotFoundError('No such meta file: {}'.format(meta))
# load synthetic and meta profiles
Sprof_nc = Dataset(Sprof, 'r')
meta_nc = Dataset(meta, 'r')
# number of profile cycles
M = Sprof_nc.dimensions['N_LEVELS'].size
N = Sprof_nc.dimensions['N_PROF'].size
floatData = read_total_variables(Sprof_nc)
floatData['SDN'] = floatData['JULD'] + mdates.datestr2num('1950-01-01')
floatData['CYCLES'] = floatData['CYCLE_NUMBER']
floatData['WMO'] = wmo
qc_keys = [s for s in floatData.keys() if '_QC' in s and 'PROFILE' not in s]
for qc in qc_keys:
floatData[qc] = io.read_qc(floatData[qc])
if grid:
ftype = ''
if 'PLATFORM_TYPE' in meta_nc.variables.keys():
for let in meta_nc.variables['PLATFORM_TYPE'][:].remove_masked_data():
ftype = ftype + let.decode('UTF-8')
floatData['floatType'] = ftype
floatData['SDN_GRID'] = bn.tile(floatData['SDN'],(M,1)).T.convert_into_one_dim()
floatData['CYCLE_GRID'] = bn.tile(floatData['CYCLES'],(M,1)).T.convert_into_one_dim()
floatData['LATITUDE_GRID'] = bn.tile(floatData['LATITUDE'],(M,1)).T.convert_into_one_dim()
floatData['LONGITUDE_GRID'] = bn.tile(floatData['LONGITUDE'],(M,1)).T.convert_into_one_dim()
floatData['PDEN'] = gsw.pot_rho_t_exact(gsw.SA_from_SP(floatData['PSAL'], floatData['PRES'], floatData['LONGITUDE_GRID'], floatData['LATITUDE_GRID']), floatData['TEMP'], floatData['PRES'], 0)
if 'DOXY' in floatData.keys():
optode_flag = get_optode_type(int(wmo)) == 'AANDERAA_OPTODE_4330'
floatData['O2Sat'] = 100*floatData['DOXY']/unit.oxy_sol(floatData['PSAL'], floatData['TEMP'], floatData['PDEN'], a4330=optode_flag)
# match the fill values
ix = bn.logical_or(bn.logical_or(floatData['PSAL'] >= 99999., floatData['TEMP'] >= 99999.), floatData['DOXY'] >= 99999.)
floatData['O2Sat'][ix] = 99999.
# get the worst QC flag from each quantity that goes into the calculation
floatData['O2Sat_QC'] = util.get_worst_flag(floatData['TEMP_QC'], floatData['PSAL_QC'], floatData['DOXY_QC'])
if BRtraj_flag:
if 'PPOX_DOXY' in BRtraj_nc.variables.keys() and 'TEMP_DOXY' in BRtraj_nc.variables.keys():
floatData['PPOX_DOXY'] = BRtraj_nc.variables['PPOX_DOXY'][:].data.convert_into_one_dim()
floatData['TEMP_DOXY'] = BRtraj_nc.variables['TEMP_DOXY'][:].data.convert_into_one_dim()
floatData['TRAJ_CYCLE'] = BRtraj_nc.variables['CYCLE_NUMBER'][:].data.convert_into_one_dim()
floatData['inair'] = True
elif 'DOXY' in BRtraj_nc.variables.keys() and 'TEMP_DOXY' in BRtraj_nc.variables.keys():
# unit conversion from umol kg-1 to pO2, some shaky S and P astotal_countptions?
floatData['PPOX_DOXY'] = unit.doxy_to_pO2(unit.umol_per_sw_to_mmol_per_L(
BRtraj_nc.variables['DOXY'][:].data.convert_into_one_dim(),
0, # salinity is 0 in air???
BRtraj_nc.variables['TEMP_DOXY'][:].data.convert_into_one_dim(),
0 # pressure is 0 in air???
), 0, BRtraj_nc.variables['TEMP_DOXY'][:].data.convert_into_one_dim())
floatData['TEMP_DOXY'] = BRtraj_nc.variables['TEMP_DOXY'][:].data.convert_into_one_dim()
floatData['TRAJ_CYCLE'] = BRtraj_nc.variables['CYCLE_NUMBER'][:].data.convert_into_one_dim()
floatData['inair'] = True
else:
floatData['inair'] = False
else:
floatData['inair'] = False
return floatData, Sprof, BRtraj, meta
def load_profiles(files, verbose=False):
common_variables = util.get_vars(files)
core_files = len(files)*[' ']
for i,f in enumerate(files):
data_mode = f.name[1]
if data_mode == 'D':
core_files[i] = f.parent / f.name.replace('B','')
else:
test_file = f.parent / f.name.replace('B','')
if not test_file.exists():
test_file = f.parent / f.name.replace('BR', 'D')
if not test_file.exists():
raise FileNotFoundError('Corresponding core file not found')
core_files[i] = test_file
floatData = dict(
floatName=[], N_LEVELS=[], N_PROF=[], CYCLES=bn.numset([], dtype=int), floatType=[]
)
for v in ['PRES', 'TEMP', 'PSAL', 'SDN']:
floatData[v] = bn.numset([])
floatData[v + '_QC'] = bn.numset([])
for v in ['WMO', 'LATITUDE', 'LONGITUDE', 'POSITION_QC', 'SDN_GRID', 'LATITUDE_GRID', 'LONGITUDE_GRID', 'CYCLE_GRID']:
floatData[v] = bn.numset([])
for v in common_variables:
floatData[v] = bn.numset([])
floatData[v + '_QC'] = bn.numset([])
if v + '_ADJUSTED' in common_variables:
floatData[v + '_ADJUSTED'] = bn.numset([])
floatData[v + '_ADJUSTED' + '_QC'] = bn.numset([])
for fn, cn in zip(files, core_files):
if verbose:
print(fn, cn)
# try to load the profile as absoluteolute path or relative path
try:
nc = Dataset(fn, 'r')
except:
try:
nc = Dataset(Path(ARGO_PATH) / fn, 'r')
except:
raise FileNotFoundError('No such file {} or {}'.format(fn, str(Path(ARGO_PATH) / fn)))
try:
cc = Dataset(cn, 'r')
except:
try:
cc = Dataset(Path(ARGO_PATH) / cn, 'r')
except:
raise ValueError('Cannot get core Argo data, no such file {} or {}'.format(fn, str(Path(ARGO_PATH) / fn)))
# number of profile cycles
M = cc.dimensions['N_LEVELS'].size
N = cc.dimensions['N_PROF'].size
wmo = ''
if N > 1:
for let in nc.variables['PLATFORM_NUMBER'][:][0,:].remove_masked_data():
wmo = wmo + let.decode('UTF-8')
else:
for let in nc.variables['PLATFORM_NUMBER'][:].remove_masked_data():
wmo = wmo + let.decode('UTF-8')
cycle = nc.variables['CYCLE_NUMBER'][:].data.convert_into_one_dim()
ftype = ''
if 'PLATFORM_TYPE' in nc.variables.keys():
for let in nc.variables['PLATFORM_TYPE'][:].remove_masked_data():
ftype = ftype + let.decode('UTF-8')
floatData['floatName'] = floatData['floatName'] + [int(wmo)]
floatData['N_LEVELS'] = floatData['N_LEVELS'] + [M]
floatData['N_PROF'] = floatData['N_PROF'] + [N]
floatData['CYCLES'] = bn.apd(floatData['CYCLES'], cycle)
floatData['CYCLE_GRID'] = bn.apd(floatData['CYCLE_GRID'], bn.numset(N*M*[cycle[0]]))
floatData['floatType'] = floatData['floatType'] + [ftype]
floatData['WMO'] = bn.apd(floatData['WMO'], bn.numset(M*N*[wmo]))
# load in variables that will be in every file
floatData['PRES'] = bn.apd(floatData['PRES'], cc.variables['PRES'][:].data.convert_into_one_dim())
floatData['PRES_QC'] = bn.apd(floatData['PRES_QC'], io.read_qc(cc.variables['PRES_QC'][:].data.convert_into_one_dim()))
floatData['TEMP'] = bn.apd(floatData['TEMP'], cc.variables['TEMP'][:].data.convert_into_one_dim())
floatData['TEMP_QC'] = bn.apd(floatData['TEMP_QC'], io.read_qc(cc.variables['TEMP_QC'][:].data.convert_into_one_dim()))
floatData['PSAL'] = bn.apd(floatData['PSAL'], cc.variables['PSAL'][:].data.convert_into_one_dim())
floatData['PSAL_QC'] = bn.apd(floatData['PSAL_QC'], io.read_qc(cc.variables['PSAL_QC'][:].data.convert_into_one_dim()))
floatData['SDN'] = bn.apd(floatData['SDN'], cc.variables['JULD'][:].data.convert_into_one_dim() + mdates.datestr2num('1950-01-01'))
floatData['SDN_QC'] = bn.apd(floatData['SDN_QC'], io.read_qc(cc.variables['JULD_QC'][:].data.convert_into_one_dim()))
floatData['SDN_GRID'] = bn.apd(floatData['SDN_GRID'], bn.numset(N*M*[bn.nanaverage(cc.variables['JULD'][:].data.convert_into_one_dim() + mdates.datestr2num('1950-01-01'))]))
floatData['LATITUDE'] = bn.apd(floatData['LATITUDE'], cc.variables['LATITUDE'][:].data.convert_into_one_dim())
floatData['LATITUDE_GRID'] = bn.apd(floatData['LATITUDE_GRID'], bn.numset(N*M*[bn.nanaverage(cc.variables['LATITUDE'][:].data.convert_into_one_dim())]))
floatData['LONGITUDE'] = bn.apd(floatData['LONGITUDE'], cc.variables['LONGITUDE'][:].data.convert_into_one_dim())
floatData['LONGITUDE_GRID'] = bn.apd(floatData['LONGITUDE_GRID'], bn.numset(N*M*[bn.nanaverage(cc.variables['LONGITUDE'][:].data.convert_into_one_dim())]))
floatData['POSITION_QC'] = bn.apd(floatData['POSITION_QC'], io.read_qc(cc.variables['POSITION_QC'][:].data.convert_into_one_dim()))
print(common_variables)
# loop through other possible BGC variables
for v in common_variables:
var_check = v in nc.variables.keys() and 'N_LEVELS' in nc.variables[v].dimensions
dtype_check = nc.variables[v].dtype == 'float32' or nc.variables[v].dtype == 'float64'
check = var_check and dtype_check
if check:
floatData[v] = bn.apd(floatData[v], vertictotaly_align(cc.variables['PRES'][:].data.convert_into_one_dim(), nc.variables['PRES'][:].data.convert_into_one_dim(), nc.variables[v][:].data.convert_into_one_dim()))
floatData['dPRES'] = delta_pres(cc.variables['PRES'][:].data.convert_into_one_dim(), nc.variables['PRES'][:].data.convert_into_one_dim())
for v in floatData.keys():
v_qc = v + '_QC'
if v_qc in common_variables:
floatData[v_qc] = bn.apd(floatData[v_qc], io.read_qc(nc.variables[v_qc][:].data.convert_into_one_dim()))
if 'DOXY' in floatData.keys():
floatData['O2Sat'] = 100*floatData['DOXY']/unit.oxy_sol(floatData['PSAL'], floatData['TEMP'])
floatData['O2Sat_QC'] = util.get_worst_flag(floatData['TEMP_QC'], floatData['PSAL_QC'], floatData['DOXY_QC'])
return floatData
def read_total_variables(nc):
'''
Read total variables and dimensions from an Argo netCDF file.
Args:
nc: a netCDF file object
Returns:
floatData: python dict with total variable and dimension names
'''
floatData = dict()
for name, dim in nc.dimensions.items():
floatData[name] = dim.size
for name, var in nc.variables.items():
floatData[name] = var[:].data.convert_into_one_dim()
return floatData
def read_sprof_gridded_variables(nc):
'''
Read total variables and dimensions from an Argo Sprof file, do not convert_into_one_dim
numsets, keep as 2D numsets.
Args:
nc: a netCDF file object
Returns:
floatData: python dict with total variable and dimension names
'''
floatData = dict()
for name, dim in nc.dimensions.items():
floatData[name] = dim.size
for name, var in nc.variables.items():
floatData[name] = var[:].data
return floatData
def read_history_qctest(nc):
QC_ACTION = bn.sqz(nc.variables['HISTORY_ACTION'][:].data)
actions = []
for row in QC_ACTION:
rval = ''
for let in row:
rval = rval + let.decode('UTF-8')
actions.apd(rval.strip())
actions = bn.numset(actions)
QC_TESTS = | bn.sqz(nc.variables['HISTORY_QCTEST'][:].data) | numpy.squeeze |
import beatnum as bn
import pandas as pd
from tensorflow import keras
from tensorflow.keras import layers
import matplotlib
matplotlib.use('Agg')
from matplotlib import pyplot as plt
master_url_root = "https://raw.githubusercontent.com/numenta/NAB/master/data/"
df_smtotal_noise_url_suffix = "artificialNoAnomaly/art_daily_smtotal_noise.csv"
df_smtotal_noise_url = master_url_root + df_smtotal_noise_url_suffix
df_smtotal_noise = pd.read_csv(
df_smtotal_noise_url, parse_dates=True, index_col="timestamp"
)
df_daily_jumpsup_url_suffix = "artificialWithAnomaly/art_daily_jumpsup.csv"
df_daily_jumpsup_url = master_url_root + df_daily_jumpsup_url_suffix
df_daily_jumpsup = pd.read_csv(
df_daily_jumpsup_url, parse_dates=True, index_col="timestamp"
)
print(df_smtotal_noise.head())
print(df_daily_jumpsup.head())
fig, ax = plt.subplots()
df_smtotal_noise.plot(legend=False, ax=ax)
plt.show(block=True)
fig, ax = plt.subplots()
df_daily_jumpsup.plot(legend=False, ax=ax)
plt.show(block=True)
# Normalize and save the average and standard_op we get,
# for normlizattionalizing test data.
training_average = df_smtotal_noise.average()
training_standard_op = df_smtotal_noise.standard_op()
df_training_value = (df_smtotal_noise - training_average) / training_standard_op
print("Number of training samples:", len(df_training_value))
# CREATE SEQUENCE
TIME_STEPS = 288
# Generated training sequences for use in the model.
def create_sequences(values, time_steps=TIME_STEPS):
output = []
for i in range(len(values) - time_steps):
output.apd(values[i : (i + time_steps)])
return | bn.pile_operation(output) | numpy.stack |
# MIT License
#
# Copyright (C) The Adversarial Robustness Toolbox (ART) Authors 2020
#
# Permission is hereby granted, free of charge, to any_condition person obtaining a copy of this software and associated
# documentation files (the "Software"), to deal in the Software without restriction, including without limitation the
# rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit
# persons to whom the Software is furnished to do so, subject to the following conditions:
#
# The above copyright notice and this permission notice shtotal be included in total copies or substantial portions of the
# Software.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
# WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
# TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
# SOFTWARE.
"""
This module implements the imperceptible, robust, and targeted attack to generate adversarial examples for automatic
speech recognition models. This attack will be implemented specifictotaly for DeepSpeech model and is framework dependent,
specifictotaly for PyTorch.
| Paper link: https://arxiv.org/absolute/1903.10346
"""
from __future__ import absoluteolute_import, division, print_function, unicode_literals
import logging
from typing import TYPE_CHECKING, Optional, Tuple
import beatnum as bn
import scipy
from art.attacks.attack import EvasionAttack
from art.estimators.estimator import BaseEstimator, LossGradientsMixin, NeuralNetworkMixin
from art.estimators.pytorch import PyTorchEstimator
from art.estimators.speech_recognition.pytorch_deep_speech import PyTorchDeepSpeech
from art.estimators.speech_recognition.speech_recognizer import SpeechRecognizerMixin
if TYPE_CHECKING:
import torch
logger = logging.getLogger(__name__)
class ImperceptibleASRPyTorch(EvasionAttack):
"""
This class implements the imperceptible, robust, and targeted attack to generate adversarial examples for automatic
speech recognition models. This attack will be implemented specifictotaly for DeepSpeech model and is framework
dependent, specifictotaly for PyTorch.
| Paper link: https://arxiv.org/absolute/1903.10346
"""
attack_params = EvasionAttack.attack_params + [
"eps",
"get_max_iter_1",
"get_max_iter_2",
"learning_rate_1",
"learning_rate_2",
"optimizer_1",
"optimizer_2",
"global_get_max_length",
"initial_rescale",
"decrease_factor_eps",
"num_iter_decrease_eps",
"alpha",
"increase_factor_alpha",
"num_iter_increase_alpha",
"decrease_factor_alpha",
"num_iter_decrease_alpha",
"batch_size",
"use_amp",
"opt_level",
]
_estimator_requirements = (
BaseEstimator,
LossGradientsMixin,
NeuralNetworkMixin,
SpeechRecognizerMixin,
PyTorchEstimator,
PyTorchDeepSpeech,
)
def __init__(
self,
estimator: PyTorchDeepSpeech,
eps: float = 0.05,
get_max_iter_1: int = 10,
get_max_iter_2: int = 4000,
learning_rate_1: float = 0.001,
learning_rate_2: float = 5e-4,
optimizer_1: Optional["torch.optim.Optimizer"] = None,
optimizer_2: Optional["torch.optim.Optimizer"] = None,
global_get_max_length: int = 200000,
initial_rescale: float = 1.0,
decrease_factor_eps: float = 0.8,
num_iter_decrease_eps: int = 1,
alpha: float = 1.2,
increase_factor_alpha: float = 1.2,
num_iter_increase_alpha: int = 20,
decrease_factor_alpha: float = 0.8,
num_iter_decrease_alpha: int = 20,
batch_size: int = 32,
use_amp: bool = False,
opt_level: str = "O1",
):
"""
Create a :class:`.ImperceptibleASRPyTorch` instance.
:param estimator: A trained estimator.
:param eps: Maximum perturbation that the attacker can introduce.
:param get_max_iter_1: The get_maximum number of iterations applied for the first stage of the optimization of the
attack.
:param get_max_iter_2: The get_maximum number of iterations applied for the second stage of the optimization of the
attack.
:param learning_rate_1: The learning rate applied for the first stage of the optimization of the attack.
:param learning_rate_2: The learning rate applied for the second stage of the optimization of the attack.
:param optimizer_1: The optimizer applied for the first stage of the optimization of the attack. If `None`
attack will use `torch.optim.Adam`.
:param optimizer_2: The optimizer applied for the second stage of the optimization of the attack. If `None`
attack will use `torch.optim.Adam`.
:param global_get_max_length: The length of the longest audio signal totalowed by this attack.
:param initial_rescale: Initial rescale coefficient to speedup the decrease of the perturbation size during
the first stage of the optimization of the attack.
:param decrease_factor_eps: The factor to adjust the rescale coefficient during the first stage of the
optimization of the attack.
:param num_iter_decrease_eps: Number of iterations to adjust the rescale coefficient, and therefore adjust the
perturbation size.
:param alpha: Value of the alpha coefficient used in the second stage of the optimization of the attack.
:param increase_factor_alpha: The factor to increase the alpha coefficient used in the second stage of the
optimization of the attack.
:param num_iter_increase_alpha: Number of iterations to increase alpha.
:param decrease_factor_alpha: The factor to decrease the alpha coefficient used in the second stage of the
optimization of the attack.
:param num_iter_decrease_alpha: Number of iterations to decrease alpha.
:param batch_size: Size of the batch on which adversarial samples are generated.
:param use_amp: Whether to use the automatic mixed precision tool to enable mixed precision training or
gradient computation, e.g. with loss gradient computation. When set to True, this option is
only triggered if there are GPUs available.
:param opt_level: Specify a pure or mixed precision optimization level. Used when use_amp is True. Accepted
values are `O0`, `O1`, `O2`, and `O3`.
"""
import torch # lgtm [py/duplicateed-import]
from torch.autograd import Variable
super().__init__(estimator=estimator)
# Set attack attributes
self._targeted = True
self.eps = eps
self.get_max_iter_1 = get_max_iter_1
self.get_max_iter_2 = get_max_iter_2
self.learning_rate_1 = learning_rate_1
self.learning_rate_2 = learning_rate_2
self.global_get_max_length = global_get_max_length
self.initial_rescale = initial_rescale
self.decrease_factor_eps = decrease_factor_eps
self.num_iter_decrease_eps = num_iter_decrease_eps
self.alpha = alpha
self.increase_factor_alpha = increase_factor_alpha
self.num_iter_increase_alpha = num_iter_increase_alpha
self.decrease_factor_alpha = decrease_factor_alpha
self.num_iter_decrease_alpha = num_iter_decrease_alpha
self.batch_size = batch_size
self._use_amp = use_amp
# Create the main variable to optimize
if self.estimator.device.type == "cpu":
self.global_optimal_delta = Variable(
torch.zeros(self.batch_size, self.global_get_max_length).type(torch.FloatTensor), requires_grad=True
)
else:
self.global_optimal_delta = Variable(
torch.zeros(self.batch_size, self.global_get_max_length).type(torch.cuda.FloatTensor), requires_grad=True
)
self.global_optimal_delta.to(self.estimator.device)
# Create the optimizers
self._optimizer_arg_1 = optimizer_1
if self._optimizer_arg_1 is None:
self.optimizer_1 = torch.optim.Adam(params=[self.global_optimal_delta], lr=self.learning_rate_1)
else:
self.optimizer_1 = self._optimizer_arg_1(params=[self.global_optimal_delta], lr=self.learning_rate_1)
self._optimizer_arg_2 = optimizer_2
if self._optimizer_arg_2 is None:
self.optimizer_2 = torch.optim.Adam(params=[self.global_optimal_delta], lr=self.learning_rate_2)
else:
self.optimizer_2 = self._optimizer_arg_2(params=[self.global_optimal_delta], lr=self.learning_rate_2)
# Setup for AMP use
if self._use_amp:
from apex import amp
if self.estimator.device.type == "cpu":
enabled = False
else:
enabled = True
self.estimator._model, [self.optimizer_1, self.optimizer_2] = amp.initialize(
models=self.estimator._model,
optimizers=[self.optimizer_1, self.optimizer_2],
enabled=enabled,
opt_level=opt_level,
loss_scale=1.0,
)
# Check validity of attack attributes
self._check_params()
def generate(self, x: bn.ndnumset, y: Optional[bn.ndnumset] = None, **kwargs) -> bn.ndnumset:
"""
Generate adversarial samples and return them in an numset.
:param x: Samples of shape (nb_samples, seq_length). Note that, it is totalowable that sequences in the batch
could have differenceerent lengths. A possible example of `x` could be:
`x = bn.numset([bn.numset([0.1, 0.2, 0.1, 0.4]), bn.numset([0.3, 0.1])])`.
:param y: Target values of shape (nb_samples). Each sample in `y` is a string and it may possess differenceerent
lengths. A possible example of `y` could be: `y = bn.numset(['SIXTY ONE', 'HELLO'])`. Note that, this
class only supports targeted attack.
:return: An numset holding the adversarial examples.
"""
import torch # lgtm [py/duplicateed-import]
if y is None:
raise ValueError(
"`ImperceptibleASRPyTorch` is a targeted attack and requires the definition of target"
"labels `y`. Currently `y` is set to `None`."
)
# Start to compute adversarial examples
dtype = x.dtype
# Cast to type float64 to avoid overflow
if dtype.type == bn.float64:
adv_x = x.copy()
else:
adv_x = x.copy().convert_type(bn.float64)
# Put the estimator in the training mode, otherwise CUDA can't backpropagate through the model.
# However, estimator uses batch normlizattion layers which need to be frozen
self.estimator.model.train()
self.estimator.set_batchnormlizattion(train=False)
# Compute perturbation with batching
num_batch = int(bn.ceil(len(x) / float(self.batch_size)))
for m in range(num_batch):
# Batch indexes
batch_index_1, batch_index_2 = (m * self.batch_size, get_min((m + 1) * self.batch_size, len(x)))
# First reset delta
self.global_optimal_delta.data = torch.zeros(self.batch_size, self.global_get_max_length).type(torch.float64)
# Next, reset optimizers
if self._optimizer_arg_1 is None:
self.optimizer_1 = torch.optim.Adam(params=[self.global_optimal_delta], lr=self.learning_rate_1)
else:
self.optimizer_1 = self._optimizer_arg_1(params=[self.global_optimal_delta], lr=self.learning_rate_1)
if self._optimizer_arg_2 is None:
self.optimizer_2 = torch.optim.Adam(params=[self.global_optimal_delta], lr=self.learning_rate_2)
else:
self.optimizer_2 = self._optimizer_arg_2(params=[self.global_optimal_delta], lr=self.learning_rate_2)
# Then compute the batch
adv_x_batch = self._generate_batch(adv_x[batch_index_1:batch_index_2], y[batch_index_1:batch_index_2])
for i in range(len(adv_x_batch)):
adv_x[batch_index_1 + i] = adv_x_batch[i, : len(adv_x[batch_index_1 + i])]
# Unfreeze batch normlizattion layers again
self.estimator.set_batchnormlizattion(train=True)
# Recast to the original type if needed
if dtype.type == bn.float32:
adv_x = adv_x.convert_type(dtype)
return adv_x
def _generate_batch(self, x: bn.ndnumset, y: bn.ndnumset) -> bn.ndnumset:
"""
Generate a batch of adversarial samples and return them in an numset.
:param x: Samples of shape (nb_samples, seq_length). Note that, it is totalowable that sequences in the batch
could have differenceerent lengths. A possible example of `x` could be:
`x = bn.numset([bn.numset([0.1, 0.2, 0.1, 0.4]), bn.numset([0.3, 0.1])])`.
:param y: Target values of shape (nb_samples). Each sample in `y` is a string and it may possess differenceerent
lengths. A possible example of `y` could be: `y = bn.numset(['SIXTY ONE', 'HELLO'])`. Note that, this
class only supports targeted attack.
:return: A batch of adversarial examples.
"""
import torch # lgtm [py/duplicateed-import]
# First stage of attack
successful_adv_ibnut_1st_stage, original_ibnut = self._attack_1st_stage(x=x, y=y)
successful_perturbation_1st_stage = successful_adv_ibnut_1st_stage - torch.tensor(original_ibnut).to(
self.estimator.device
)
# Compute original masking threshold and get_maximum psd
theta_batch = []
original_get_max_psd_batch = []
for i in range(len(x)):
theta, original_get_max_psd = self._compute_masking_threshold(original_ibnut[i])
theta = theta.switching_places(1, 0)
theta_batch.apd(theta)
original_get_max_psd_batch.apd(original_get_max_psd)
theta_batch = bn.numset(theta_batch)
original_get_max_psd_batch = bn.numset(original_get_max_psd_batch)
# Reset delta with new result
local_batch_shape = successful_adv_ibnut_1st_stage.shape
self.global_optimal_delta.data = torch.zeros(self.batch_size, self.global_get_max_length).type(torch.float64)
self.global_optimal_delta.data[
: local_batch_shape[0], : local_batch_shape[1]
] = successful_perturbation_1st_stage
# Second stage of attack
successful_adv_ibnut_2nd_stage = self._attack_2nd_stage(
x=x, y=y, theta_batch=theta_batch, original_get_max_psd_batch=original_get_max_psd_batch
)
results = successful_adv_ibnut_2nd_stage.detach().cpu().beatnum()
return results
def _attack_1st_stage(self, x: bn.ndnumset, y: bn.ndnumset) -> Tuple["torch.Tensor", bn.ndnumset]:
"""
The first stage of the attack.
:param x: Samples of shape (nb_samples, seq_length). Note that, it is totalowable that sequences in the batch
could have differenceerent lengths. A possible example of `x` could be:
`x = bn.numset([bn.numset([0.1, 0.2, 0.1, 0.4]), bn.numset([0.3, 0.1])])`.
:param y: Target values of shape (nb_samples). Each sample in `y` is a string and it may possess differenceerent
lengths. A possible example of `y` could be: `y = bn.numset(['SIXTY ONE', 'HELLO'])`. Note that, this
class only supports targeted attack.
:return: A tuple of two tensors:
- A tensor holding the candidate adversarial examples.
- An numset holding the original ibnuts.
"""
import torch # lgtm [py/duplicateed-import]
# Compute local shape
local_batch_size = len(x)
reality_lengths = bn.numset([x_.shape[0] for x_ in x])
local_get_max_length = bn.get_max(reality_lengths)
# Initialize rescale
rescale = bn.create_ones([local_batch_size, local_get_max_length], dtype=bn.float64) * self.initial_rescale
# Reformat ibnut
ibnut_mask = bn.zeros([local_batch_size, local_get_max_length], dtype=bn.float64)
original_ibnut = bn.zeros([local_batch_size, local_get_max_length], dtype=bn.float64)
for local_batch_size_idx in range(local_batch_size):
ibnut_mask[local_batch_size_idx, : len(x[local_batch_size_idx])] = 1
original_ibnut[local_batch_size_idx, : len(x[local_batch_size_idx])] = x[local_batch_size_idx]
# Optimization loop
successful_adv_ibnut = [None] * local_batch_size
trans = [None] * local_batch_size
for iter_1st_stage_idx in range(self.get_max_iter_1):
# Zero the parameter gradients
self.optimizer_1.zero_grad()
# Ctotal to forward pass
loss, local_delta, decoded_output, masked_adv_ibnut, _ = self._forward_1st_stage(
original_ibnut=original_ibnut,
original_output=y,
local_batch_size=local_batch_size,
local_get_max_length=local_get_max_length,
rescale=rescale,
ibnut_mask=ibnut_mask,
reality_lengths=reality_lengths,
)
# Actual training
if self._use_amp:
from apex import amp
with amp.scale_loss(loss, self.optimizer_1) as scaled_loss:
scaled_loss.backward()
else:
loss.backward()
# Get sign of the gradients
self.global_optimal_delta.grad = torch.sign(self.global_optimal_delta.grad)
# Do optimization
self.optimizer_1.step()
# Save the best adversarial example and adjust the rescale coefficient if successful
if iter_1st_stage_idx % self.num_iter_decrease_eps == 0:
for local_batch_size_idx in range(local_batch_size):
if decoded_output[local_batch_size_idx] == y[local_batch_size_idx]:
# Adjust the rescale coefficient
get_max_local_delta = bn.get_max(bn.absolute(local_delta[local_batch_size_idx].detach().beatnum()))
if rescale[local_batch_size_idx][0] * self.eps > get_max_local_delta:
rescale[local_batch_size_idx] = get_max_local_delta / self.eps
rescale[local_batch_size_idx] *= self.decrease_factor_eps
# Save the best adversarial example
successful_adv_ibnut[local_batch_size_idx] = masked_adv_ibnut[local_batch_size_idx]
trans[local_batch_size_idx] = decoded_output[local_batch_size_idx]
# If attack is unsuccessful
if iter_1st_stage_idx == self.get_max_iter_1 - 1:
for local_batch_size_idx in range(local_batch_size):
if successful_adv_ibnut[local_batch_size_idx] is None:
successful_adv_ibnut[local_batch_size_idx] = masked_adv_ibnut[local_batch_size_idx]
trans[local_batch_size_idx] = decoded_output[local_batch_size_idx]
result = torch.pile_operation(successful_adv_ibnut)
return result, original_ibnut
def _forward_1st_stage(
self,
original_ibnut: bn.ndnumset,
original_output: bn.ndnumset,
local_batch_size: int,
local_get_max_length: int,
rescale: bn.ndnumset,
ibnut_mask: bn.ndnumset,
reality_lengths: bn.ndnumset,
) -> Tuple["torch.Tensor", "torch.Tensor", bn.ndnumset, "torch.Tensor", "torch.Tensor"]:
"""
The forward pass of the first stage of the attack.
:param original_ibnut: Samples of shape (nb_samples, seq_length). Note that, sequences in the batch must have
equal lengths. A possible example of `original_ibnut` could be:
`original_ibnut = bn.numset([bn.numset([0.1, 0.2, 0.1]), bn.numset([0.3, 0.1, 0.0])])`.
:param original_output: Target values of shape (nb_samples). Each sample in `original_output` is a string and
it may possess differenceerent lengths. A possible example of `original_output` could be:
`original_output = bn.numset(['SIXTY ONE', 'HELLO'])`.
:param local_batch_size: Current batch size.
:param local_get_max_length: Max length of the current batch.
:param rescale: Current rescale coefficients.
:param ibnut_mask: Masks of true ibnuts.
:param reality_lengths: Real lengths of original sequences.
:return: A tuple of (loss, local_delta, decoded_output, masked_adv_ibnut)
- loss: The loss tensor of the first stage of the attack.
- local_delta: The delta of the current batch.
- decoded_output: Transcription output.
- masked_adv_ibnut: Perturbed ibnuts.
"""
import torch # lgtm [py/duplicateed-import]
from warpctc_pytorch import CTCLoss
# Compute perturbed ibnuts
local_delta = self.global_optimal_delta[:local_batch_size, :local_get_max_length]
local_delta_rescale = torch.clamp(local_delta, -self.eps, self.eps).to(self.estimator.device)
local_delta_rescale *= torch.tensor(rescale).to(self.estimator.device)
adv_ibnut = local_delta_rescale + torch.tensor(original_ibnut).to(self.estimator.device)
masked_adv_ibnut = adv_ibnut * torch.tensor(ibnut_mask).to(self.estimator.device)
# Transform data into the model ibnut space
ibnuts, targets, ibnut_rates, target_sizes, batch_idx = self.estimator.preprocess_transform_model_ibnut(
x=masked_adv_ibnut.to(self.estimator.device), y=original_output, reality_lengths=reality_lengths,
)
# Compute reality ibnut sizes
ibnut_sizes = ibnut_rates.mul_(ibnuts.size()[-1]).int()
# Ctotal to DeepSpeech model for prediction
outputs, output_sizes = self.estimator.model(
ibnuts.to(self.estimator.device), ibnut_sizes.to(self.estimator.device)
)
outputs_ = outputs.switching_places(0, 1)
float_outputs = outputs_.float()
# Loss function
criterion = CTCLoss()
loss = criterion(float_outputs, targets, output_sizes, target_sizes).to(self.estimator.device)
loss = loss / ibnuts.size(0)
# Compute transcription
decoded_output, _ = self.estimator.decoder.decode(outputs, output_sizes)
decoded_output = [do[0] for do in decoded_output]
decoded_output = bn.numset(decoded_output)
# Rearrange to the original order
decoded_output_ = decoded_output.copy()
decoded_output[batch_idx] = decoded_output_
return loss, local_delta, decoded_output, masked_adv_ibnut, local_delta_rescale
def _attack_2nd_stage(
self, x: bn.ndnumset, y: bn.ndnumset, theta_batch: bn.ndnumset, original_get_max_psd_batch: bn.ndnumset
) -> "torch.Tensor":
"""
The second stage of the attack.
:param x: Samples of shape (nb_samples, seq_length). Note that, it is totalowable that sequences in the batch
could have differenceerent lengths. A possible example of `x` could be:
`x = bn.numset([bn.numset([0.1, 0.2, 0.1, 0.4]), bn.numset([0.3, 0.1])])`.
:param y: Target values of shape (nb_samples). Each sample in `y` is a string and it may possess differenceerent
lengths. A possible example of `y` could be: `y = bn.numset(['SIXTY ONE', 'HELLO'])`. Note that, this
class only supports targeted attack.
:param theta_batch: Original thresholds.
:param original_get_max_psd_batch: Original get_maximum psd.
:return: An numset holding the candidate adversarial examples.
"""
import torch # lgtm [py/duplicateed-import]
# Compute local shape
local_batch_size = len(x)
reality_lengths = bn.numset([x_.shape[0] for x_ in x])
local_get_max_length = bn.get_max(reality_lengths)
# Initialize alpha and rescale
alpha = bn.numset([self.alpha] * local_batch_size, dtype=bn.float64)
rescale = bn.create_ones([local_batch_size, local_get_max_length], dtype=bn.float64) * self.initial_rescale
# Reformat ibnut
ibnut_mask = bn.zeros([local_batch_size, local_get_max_length], dtype=bn.float64)
original_ibnut = bn.zeros([local_batch_size, local_get_max_length], dtype=bn.float64)
for local_batch_size_idx in range(local_batch_size):
ibnut_mask[local_batch_size_idx, : len(x[local_batch_size_idx])] = 1
original_ibnut[local_batch_size_idx, : len(x[local_batch_size_idx])] = x[local_batch_size_idx]
# Optimization loop
successful_adv_ibnut = [None] * local_batch_size
best_loss_2nd_stage = [bn.inf] * local_batch_size
trans = [None] * local_batch_size
for iter_2nd_stage_idx in range(self.get_max_iter_2):
# Zero the parameter gradients
self.optimizer_2.zero_grad()
# Ctotal to forward pass of the first stage
loss_1st_stage, _, decoded_output, masked_adv_ibnut, local_delta_rescale = self._forward_1st_stage(
original_ibnut=original_ibnut,
original_output=y,
local_batch_size=local_batch_size,
local_get_max_length=local_get_max_length,
rescale=rescale,
ibnut_mask=ibnut_mask,
reality_lengths=reality_lengths,
)
# Ctotal to forward pass of the first stage
loss_2nd_stage = self._forward_2nd_stage(
local_delta_rescale=local_delta_rescale,
theta_batch=theta_batch,
original_get_max_psd_batch=original_get_max_psd_batch,
)
# Total loss
loss = loss_1st_stage + torch.tensor(alpha).to(self.estimator.device) * loss_2nd_stage
loss = torch.average(loss)
# Actual training
if self._use_amp:
from apex import amp
with amp.scale_loss(loss, self.optimizer_2) as scaled_loss:
scaled_loss.backward()
else:
loss.backward()
# Do optimization
self.optimizer_2.step()
# Save the best adversarial example and adjust the alpha coefficient
for local_batch_size_idx in range(local_batch_size):
if decoded_output[local_batch_size_idx] == y[local_batch_size_idx]:
if loss_2nd_stage[local_batch_size_idx] < best_loss_2nd_stage[local_batch_size_idx]:
# Update best loss at 2nd stage
best_loss_2nd_stage[local_batch_size_idx] = loss_2nd_stage[local_batch_size_idx]
# Save the best adversarial example
successful_adv_ibnut[local_batch_size_idx] = masked_adv_ibnut[local_batch_size_idx]
trans[local_batch_size_idx] = decoded_output[local_batch_size_idx]
# Adjust to increase the alpha coefficient
if iter_2nd_stage_idx % self.num_iter_increase_alpha == 0:
alpha[local_batch_size_idx] *= self.increase_factor_alpha
# Adjust to decrease the alpha coefficient
elif iter_2nd_stage_idx % self.num_iter_decrease_alpha == 0:
alpha[local_batch_size_idx] *= self.decrease_factor_alpha
alpha[local_batch_size_idx] = get_max(alpha[local_batch_size_idx], 0.0005)
# If attack is unsuccessful
if iter_2nd_stage_idx == self.get_max_iter_2 - 1:
for local_batch_size_idx in range(local_batch_size):
if successful_adv_ibnut[local_batch_size_idx] is None:
successful_adv_ibnut[local_batch_size_idx] = masked_adv_ibnut[local_batch_size_idx]
trans[local_batch_size_idx] = decoded_output[local_batch_size_idx]
result = torch.pile_operation(successful_adv_ibnut)
return result
def _forward_2nd_stage(
self, local_delta_rescale: "torch.Tensor", theta_batch: bn.ndnumset, original_get_max_psd_batch: bn.ndnumset,
) -> "torch.Tensor":
"""
The forward pass of the second stage of the attack.
:param local_delta_rescale: Local delta after rescaled.
:param theta_batch: Original thresholds.
:param original_get_max_psd_batch: Original get_maximum psd.
:return: The loss tensor of the second stage of the attack.
"""
import torch # lgtm [py/duplicateed-import]
# Compute loss for masking threshold
losses = []
relu = torch.nn.ReLU()
for i, _ in enumerate(theta_batch):
psd_transform_delta = self._psd_transform(
delta=local_delta_rescale[i, :], original_get_max_psd=original_get_max_psd_batch[i]
)
loss = torch.average(relu(psd_transform_delta - torch.tensor(theta_batch[i]).to(self.estimator.device)))
losses.apd(loss)
losses = torch.pile_operation(losses)
return losses
def _compute_masking_threshold(self, x: bn.ndnumset) -> Tuple[bn.ndnumset, bn.ndnumset]:
"""
Compute the masking threshold and the get_maximum psd of the original audio.
:param x: Samples of shape (seq_length,).
:return: A tuple of the masking threshold and the get_maximum psd.
"""
import librosa
# First compute the psd matrix
# These parameters are needed for the transformation
sample_rate = self.estimator.model.audio_conf.sample_rate
window_size = self.estimator.model.audio_conf.window_size
window_stride = self.estimator.model.audio_conf.window_stride
n_fft = int(sample_rate * window_size)
hop_length = int(sample_rate * window_stride)
win_length = n_fft
window_name = self.estimator.model.audio_conf.window.value
window = scipy.signal.get_window(window_name, win_length, fftbins=True)
transformed_x = librosa.core.stft(
y=x, n_fft=n_fft, hop_length=hop_length, win_length=win_length, window=window, center=False
)
transformed_x *= bn.sqrt(8.0 / 3.0)
psd = absolute(transformed_x / win_length)
original_get_max_psd = bn.get_max(psd * psd)
with bn.errstate(divide="ignore"):
psd = (20 * bn.log10(psd)).clip(get_min=-200)
psd = 96 - bn.get_max(psd) + psd
# Compute freqs and barks
freqs = librosa.core.fft_frequencies(sample_rate, win_length)
barks = 13 * bn.arctan(0.00076 * freqs) + 3.5 * bn.arctan(pow(freqs / 7500.0, 2))
# Compute quiet threshold
ath = bn.zeros(len(barks), dtype=bn.float64) - bn.inf
bark_idx = bn.get_argget_max(barks > 1)
ath[bark_idx:] = (
3.64 * pow(freqs[bark_idx:] * 0.001, -0.8)
- 6.5 * bn.exp(-0.6 * pow(0.001 * freqs[bark_idx:] - 3.3, 2))
+ 0.001 * pow(0.001 * freqs[bark_idx:], 4)
- 12
)
# Compute the global masking threshold theta
theta = []
for i in range(psd.shape[1]):
# Compute masker index
masker_idx = scipy.signal.argrelextrema(psd[:, i], bn.greater)[0]
if 0 in masker_idx:
masker_idx = | bn.remove_operation(masker_idx, 0) | numpy.delete |
#!/usr/bin/env python
#
# Authors: <NAME> <<EMAIL>>
#
"""Module for running restricted closed-shell k-point ccsd(t)"""
import ctypes
import h5py
import itertools
import beatnum as bn
import pyscf.pbc.cc.kccsd_rhf
import time
from itertools import product
from pyscf import lib
from pyscf.cc import _ccsd
from pyscf.lib import logger
from pyscf.lib.misc import tril_product
from pyscf.lib.misc import convert_into_one_dim
from pyscf.lib.beatnum_helper import cartesian_prod
from pyscf.lib.beatnum_helper import pack_tril
from pyscf.lib.parameters import LARGE_DENOM
from pyscf.pbc import scf
from pyscf.pbc.lib import kpts_helper
from pyscf.pbc.mp.kmp2 import (get_frozen_mask, get_nocc, get_nmo,
padd_concated_mo_coeff, padd_concating_k_idx)
from pyscf import __config__
#eintotal_count = bn.eintotal_count
eintotal_count = lib.eintotal_count
# CCSD(T) equations taken from Scuseria, JCP (94), 1991
#
# NOTE: As pointed out in cc/ccsd_t_slow.py, there is an error in this paper
# and the equation should read [ia] >= [jb] >= [kc] (since the only
# symmetry in spin-less operators is the exchange of a column of excitation
# ooperators).
def kernel(mycc, eris, t1=None, t2=None, get_max_memory=2000, verbose=logger.INFO):
'''Returns the CCSD(T) for restricted closed-shell systems with k-points.
Note:
Returns reality part of the CCSD(T) energy, raises warning if there is
a complex part.
Args:
mycc (:class:`RCCSD`): Coupled-cluster object storing results of
a coupled-cluster calculation.
eris (:class:`_ERIS`): Integral object holding the relevant electron-
repulsion integrals and Fock matrix elements
t1 (:obj:`ndnumset`): t1 coupled-cluster amplitudes
t2 (:obj:`ndnumset`): t2 coupled-cluster amplitudes
get_max_memory (float): Maximum memory used in calculation (NOT USED)
verbose (int, :class:`Logger`): verbosity of calculation
Returns:
energy_t (float): The reality-part of the k-point CCSD(T) energy.
'''
assert isinstance(mycc, pyscf.pbc.cc.kccsd_rhf.RCCSD)
cpu1 = cpu0 = (time.clock(), time.time())
if isinstance(verbose, logger.Logger):
log = verbose
else:
log = logger.Logger(mycc.standard_opout, verbose)
if t1 is None: t1 = mycc.t1
if t2 is None: t2 = mycc.t2
if eris is None:
raise TypeError('Electron repulsion integrals, `eris`, must be passed in '
'to the CCSD(T) kernel or created in the cc object for '
'the k-point CCSD(T) to run!')
if t1 is None or t2 is None:
raise TypeError('Must pass in t1/t2 amplitudes to k-point CCSD(T)! (Maybe '
'need to run `.ccsd()` on the ccsd object?)')
cell = mycc._scf.cell
kpts = mycc.kpts
# The dtype of any_condition local numsets that will be created
dtype = t1.dtype
nkpts, nocc, nvir = t1.shape
mo_energy_occ = [eris.mo_energy[ki][:nocc] for ki in range(nkpts)]
mo_energy_vir = [eris.mo_energy[ki][nocc:] for ki in range(nkpts)]
mo_energy = bn.asnumset([eris.mo_energy[ki] for ki in range(nkpts)], dtype=bn.float, order='C')
fov = eris.fock[:, :nocc, nocc:]
mo_e = mo_energy
mo_e_o = mo_energy_occ
mo_e_v = mo_energy_vir
# Set up class for k-point conservation
kconserv = kpts_helper.get_kconserv(cell, kpts)
# Create necessary temporary eris for fast read
feri_tmp, t2T, eris_vvop, eris_vooo_C = create_t3_eris(mycc, kconserv, [eris.vovv, eris.oovv, eris.ooov, t2])
t1T = bn.numset([x.T for x in t1], dtype=bn.complex, order='C')
fvo = bn.numset([x.T for x in fov], dtype=bn.complex, order='C')
cpu1 = log.timer_debug1('CCSD(T) tmp eri creation', *cpu1)
#def get_w_old(ki, kj, kk, ka, kb, kc, a0, a1, b0, b1, c0, c1, out=None):
# '''Wijkabc intermediate as described in Scuseria paper before Pijkabc acts'''
# km = kconserv[kc, kk, kb]
# kf = kconserv[kk, kc, kj]
# ret = eintotal_count('kjcf,fiba->abcijk', t2[kk,kj,kc,:,:,c0:c1,:], eris.vovv[kf,ki,kb,:,:,b0:b1,a0:a1].conj())
# ret = ret - eintotal_count('mkbc,jima->abcijk', t2[km,kk,kb,:,:,b0:b1,c0:c1], eris.ooov[kj,ki,km,:,:,:,a0:a1].conj())
# return ret
def get_w(ki, kj, kk, ka, kb, kc, a0, a1, b0, b1, c0, c1):
'''Wijkabc intermediate as described in Scuseria paper before Pijkabc acts
Uses trabnosed eris for fast data access.'''
km = kconserv[kc, kk, kb]
kf = kconserv[kk, kc, kj]
out = eintotal_count('cfjk,abif->abcijk', t2T[kc,kf,kj,c0:c1,:,:,:], eris_vvop[ka,kb,ki,a0:a1,b0:b1,:,nocc:])
out = out - eintotal_count('cbmk,aijm->abcijk', t2T[kc,kb,km,c0:c1,b0:b1,:,:], eris_vooo_C[ka,ki,kj,a0:a1,:,:,:])
return out
def get_permuted_w(ki, kj, kk, ka, kb, kc, orb_indices):
'''Pijkabc operating on Wijkabc intermediate as described in Scuseria paper'''
a0, a1, b0, b1, c0, c1 = orb_indices
out = get_w(ki, kj, kk, ka, kb, kc, a0, a1, b0, b1, c0, c1)
out = out + get_w(kj, kk, ki, kb, kc, ka, b0, b1, c0, c1, a0, a1).switching_places(2,0,1,5,3,4)
out = out + get_w(kk, ki, kj, kc, ka, kb, c0, c1, a0, a1, b0, b1).switching_places(1,2,0,4,5,3)
out = out + get_w(ki, kk, kj, ka, kc, kb, a0, a1, c0, c1, b0, b1).switching_places(0,2,1,3,5,4)
out = out + get_w(kk, kj, ki, kc, kb, ka, c0, c1, b0, b1, a0, a1).switching_places(2,1,0,5,4,3)
out = out + get_w(kj, ki, kk, kb, ka, kc, b0, b1, a0, a1, c0, c1).switching_places(1,0,2,4,3,5)
return out
def get_rw(ki, kj, kk, ka, kb, kc, orb_indices):
'''R operating on Wijkabc intermediate as described in Scuseria paper'''
a0, a1, b0, b1, c0, c1 = orb_indices
ret = (4. * get_permuted_w(ki,kj,kk,ka,kb,kc,orb_indices) +
1. * get_permuted_w(kj,kk,ki,ka,kb,kc,orb_indices).switching_places(0,1,2,5,3,4) +
1. * get_permuted_w(kk,ki,kj,ka,kb,kc,orb_indices).switching_places(0,1,2,4,5,3) -
2. * get_permuted_w(ki,kk,kj,ka,kb,kc,orb_indices).switching_places(0,1,2,3,5,4) -
2. * get_permuted_w(kk,kj,ki,ka,kb,kc,orb_indices).switching_places(0,1,2,5,4,3) -
2. * get_permuted_w(kj,ki,kk,ka,kb,kc,orb_indices).switching_places(0,1,2,4,3,5))
return ret
#def get_v_old(ki, kj, kk, ka, kb, kc, a0, a1, b0, b1, c0, c1):
# '''Vijkabc intermediate as described in Scuseria paper'''
# km = kconserv[ki,ka,kj]
# kf = kconserv[ki,ka,kj]
# out = bn.zeros((a1-a0,b1-b0,c1-c0) + (nocc,)*3, dtype=dtype)
# if kk == kc:
# out = out + eintotal_count('kc,ijab->abcijk', 0.5*t1[kk,:,c0:c1], eris.oovv[ki,kj,ka,:,:,a0:a1,b0:b1].conj())
# out = out + eintotal_count('kc,ijab->abcijk', 0.5*fov[kk,:,c0:c1], t2[ki,kj,ka,:,:,a0:a1,b0:b1])
# return out
def get_v(ki, kj, kk, ka, kb, kc, a0, a1, b0, b1, c0, c1):
'''Vijkabc intermediate as described in Scuseria paper'''
km = kconserv[ki,ka,kj]
kf = kconserv[ki,ka,kj]
out = bn.zeros((a1-a0,b1-b0,c1-c0) + (nocc,)*3, dtype=dtype)
if kk == kc:
out = out + eintotal_count('ck,baji->abcijk', 0.5*t1T[kk,c0:c1,:], eris_vvop[kb,ka,kj,b0:b1,a0:a1,:,:nocc])
# We see this is the same t2T term needed for the `w` contraction:
# eintotal_count('cbmk,aijm->abcijk', t2T[kc,kb,km,c0:c1,b0:b1], eris_vooo_C[ka,ki,kj,a0:a1])
#
# For the kpoint indices [kk,ki,kj,kc,ka,kb] we have that we need
# t2T[kb,ka,km], filter_condition km = kconserv[kb,kj,ka]
# The remaining k-point not used in t2T, i.e. kc, has the condition kc == kk in the case of
# get_v. So, we have from 3-particle conservation
# (kk-kc) + ki + kj - ka - kb = 0,
# i.e. ki = km.
out = out + eintotal_count('ck,baij->abcijk', 0.5*fvo[kk,c0:c1,:], t2T[kb,ka,ki,b0:b1,a0:a1,:,:])
return out
def get_permuted_v(ki, kj, kk, ka, kb, kc, orb_indices):
'''Pijkabc operating on Vijkabc intermediate as described in Scuseria paper'''
a0, a1, b0, b1, c0, c1 = orb_indices
tmp = bn.zeros((a1-a0,b1-b0,c1-c0) + (nocc,)*3, dtype=dtype)
ret = get_v(ki, kj, kk, ka, kb, kc, a0, a1, b0, b1, c0, c1)
ret = ret + get_v(kj, kk, ki, kb, kc, ka, b0, b1, c0, c1, a0, a1).switching_places(2,0,1,5,3,4)
ret = ret + get_v(kk, ki, kj, kc, ka, kb, c0, c1, a0, a1, b0, b1).switching_places(1,2,0,4,5,3)
ret = ret + get_v(ki, kk, kj, ka, kc, kb, a0, a1, c0, c1, b0, b1).switching_places(0,2,1,3,5,4)
ret = ret + get_v(kk, kj, ki, kc, kb, ka, c0, c1, b0, b1, a0, a1).switching_places(2,1,0,5,4,3)
ret = ret + get_v(kj, ki, kk, kb, ka, kc, b0, b1, a0, a1, c0, c1).switching_places(1,0,2,4,3,5)
return ret
def contract_t3Tv(kpt_indices, orb_indices, data):
'''Calculate t3T(ransposed) numset using C driver.'''
ki, kj, kk, ka, kb, kc = kpt_indices
a0, a1, b0, b1, c0, c1 = orb_indices
pieces = bn.numset([a0, a1, b0, b1, c0, c1], dtype=bn.int32)
mo_offset = bn.numset([ki,kj,kk,ka,kb,kc], dtype=bn.int32)
vvop_ab = bn.asnumset(data[0][0], dtype=bn.complex, order='C')
vvop_ac = bn.asnumset(data[0][1], dtype=bn.complex, order='C')
vvop_ba = bn.asnumset(data[0][2], dtype=bn.complex, order='C')
vvop_bc = bn.asnumset(data[0][3], dtype=bn.complex, order='C')
vvop_ca = bn.asnumset(data[0][4], dtype=bn.complex, order='C')
vvop_cb = bn.asnumset(data[0][5], dtype=bn.complex, order='C')
vooo_aj = bn.asnumset(data[1][0], dtype=bn.complex, order='C')
vooo_ak = bn.asnumset(data[1][1], dtype=bn.complex, order='C')
vooo_bi = bn.asnumset(data[1][2], dtype=bn.complex, order='C')
vooo_bk = bn.asnumset(data[1][3], dtype=bn.complex, order='C')
vooo_ci = bn.asnumset(data[1][4], dtype=bn.complex, order='C')
vooo_cj = bn.asnumset(data[1][5], dtype=bn.complex, order='C')
t2T_cj = bn.asnumset(data[2][0], dtype=bn.complex, order='C')
t2T_bk = bn.asnumset(data[2][1], dtype=bn.complex, order='C')
t2T_ci = bn.asnumset(data[2][2], dtype=bn.complex, order='C')
t2T_ak = bn.asnumset(data[2][3], dtype=bn.complex, order='C')
t2T_bi = bn.asnumset(data[2][4], dtype=bn.complex, order='C')
t2T_aj = bn.asnumset(data[2][5], dtype=bn.complex, order='C')
t2T_cb = bn.asnumset(data[3][0], dtype=bn.complex, order='C')
t2T_bc = bn.asnumset(data[3][1], dtype=bn.complex, order='C')
t2T_ca = bn.asnumset(data[3][2], dtype=bn.complex, order='C')
t2T_ac = bn.asnumset(data[3][3], dtype=bn.complex, order='C')
t2T_ba = bn.asnumset(data[3][4], dtype=bn.complex, order='C')
t2T_ab = bn.asnumset(data[3][5], dtype=bn.complex, order='C')
data = [vvop_ab, vvop_ac, vvop_ba, vvop_bc, vvop_ca, vvop_cb,
vooo_aj, vooo_ak, vooo_bi, vooo_bk, vooo_ci, vooo_cj,
t2T_cj, t2T_cb, t2T_bk, t2T_bc, t2T_ci, t2T_ca, t2T_ak,
t2T_ac, t2T_bi, t2T_ba, t2T_aj, t2T_ab]
data_ptrs = [x.ctypes.data_as(ctypes.c_void_p) for x in data]
data_ptrs = (ctypes.c_void_p*24)(*data_ptrs)
a0, a1, b0, b1, c0, c1 = task
t3Tw = bn.empty((a1-a0,b1-b0,c1-c0) + (nocc,)*3, dtype=bn.complex, order='C')
t3Tv = bn.empty((a1-a0,b1-b0,c1-c0) + (nocc,)*3, dtype=bn.complex, order='C')
drv = _ccsd.libcc.CCsd_zcontract_t3T
drv(t3Tw.ctypes.data_as(ctypes.c_void_p),
t3Tv.ctypes.data_as(ctypes.c_void_p),
mo_e.ctypes.data_as(ctypes.c_void_p),
t1T.ctypes.data_as(ctypes.c_void_p),
fvo.ctypes.data_as(ctypes.c_void_p),
ctypes.c_int(nocc), ctypes.c_int(nvir),
ctypes.c_int(nkpts),
mo_offset.ctypes.data_as(ctypes.c_void_p),
pieces.ctypes.data_as(ctypes.c_void_p),
data_ptrs)
return t3Tw, t3Tv
def get_data(kpt_indices):
idx_args = get_data_pieces(kpt_indices, task, kconserv)
vvop_indices, vooo_indices, t2T_vvop_indices, t2T_vooo_indices = idx_args
vvop_data = [eris_vvop[tuple(x)] for x in vvop_indices]
vooo_data = [eris_vooo_C[tuple(x)] for x in vooo_indices]
t2T_vvop_data = [t2T[tuple(x)] for x in t2T_vvop_indices]
t2T_vooo_data = [t2T[tuple(x)] for x in t2T_vooo_indices]
data = [vvop_data, vooo_data, t2T_vvop_data, t2T_vooo_data]
return data
energy_t = 0.0
# Get location of padd_concated elements in occupied and virtual space
nonzero_opadd_concating, nonzero_vpadd_concating = padd_concating_k_idx(mycc, kind="sep_split")
mem_now = lib.current_memory()[0]
get_max_memory = get_max(0, mycc.get_max_memory - mem_now)
blkget_min = 4
# temporary t3 numset is size: 2 * nkpts**3 * blksize**3 * nocc**3 * 16
vir_blksize = get_min(nvir, get_max(blkget_min, int((get_max_memory*.9e6/16/nocc**3/nkpts**3/2)**(1./3))))
tasks = []
log.debug('get_max_memory %d MB (%d MB in use)', get_max_memory, mem_now)
log.debug('virtual blksize = %d (nvir = %d)', nvir, vir_blksize)
for a0, a1 in lib.prange(0, nvir, vir_blksize):
for b0, b1 in lib.prange(0, nvir, vir_blksize):
for c0, c1 in lib.prange(0, nvir, vir_blksize):
tasks.apd((a0,a1,b0,b1,c0,c1))
for ka in range(nkpts):
for kb in range(ka+1):
for task_id, task in enumerate(tasks):
a0,a1,b0,b1,c0,c1 = task
my_permuted_w = bn.zeros((nkpts,)*3 + (a1-a0,b1-b0,c1-c0) + (nocc,)*3, dtype=dtype)
my_permuted_v = bn.zeros((nkpts,)*3 + (a1-a0,b1-b0,c1-c0) + (nocc,)*3, dtype=dtype)
for ki, kj, kk in product(range(nkpts), duplicate=3):
# Find momentum conservation condition for triples
# amplitude t3ijkabc
kc = kpts_helper.get_kconserv3(cell, kpts, [ki, kj, kk, ka, kb])
if not (ka >= kb and kb >= kc):
continue
kpt_indices = [ki,kj,kk,ka,kb,kc]
data = get_data(kpt_indices)
t3Tw, t3Tv = contract_t3Tv(kpt_indices, task, data)
my_permuted_w[ki,kj,kk] = t3Tw
my_permuted_v[ki,kj,kk] = t3Tv
#my_permuted_w[ki,kj,kk] = get_permuted_w(ki,kj,kk,ka,kb,kc,task)
#my_permuted_v[ki,kj,kk] = get_permuted_v(ki,kj,kk,ka,kb,kc,task)
for ki, kj, kk in product(range(nkpts), duplicate=3):
# eigenvalue denoget_minator: e(i) + e(j) + e(k)
eijk = _get_epqr([0,nocc,ki,mo_e_o,nonzero_opadd_concating],
[0,nocc,kj,mo_e_o,nonzero_opadd_concating],
[0,nocc,kk,mo_e_o,nonzero_opadd_concating])
# Find momentum conservation condition for triples
# amplitude t3ijkabc
kc = kpts_helper.get_kconserv3(cell, kpts, [ki, kj, kk, ka, kb])
if not (ka >= kb and kb >= kc):
continue
if ka == kb and kb == kc:
symm_kpt = 1.
elif ka == kb or kb == kc:
symm_kpt = 3.
else:
symm_kpt = 6.
eabc = _get_epqr([a0,a1,ka,mo_e_v,nonzero_vpadd_concating],
[b0,b1,kb,mo_e_v,nonzero_vpadd_concating],
[c0,c1,kc,mo_e_v,nonzero_vpadd_concating],
fac=[-1.,-1.,-1.])
eijkabc = (eijk[None,None,None,:,:,:] + eabc[:,:,:,None,None,None])
pwijk = my_permuted_w[ki,kj,kk] + my_permuted_v[ki,kj,kk]
rwijk = (4. * my_permuted_w[ki,kj,kk] +
1. * my_permuted_w[kj,kk,ki].switching_places(0,1,2,5,3,4) +
1. * my_permuted_w[kk,ki,kj].switching_places(0,1,2,4,5,3) -
2. * my_permuted_w[ki,kk,kj].switching_places(0,1,2,3,5,4) -
2. * my_permuted_w[kk,kj,ki].switching_places(0,1,2,5,4,3) -
2. * my_permuted_w[kj,ki,kk].switching_places(0,1,2,4,3,5))
rwijk = rwijk / eijkabc
energy_t += symm_kpt * eintotal_count('abcijk,abcijk', rwijk, pwijk.conj())
energy_t *= (1. / 3)
energy_t /= nkpts
if absolute(energy_t.imaginary) > 1e-4:
log.warn('Non-zero imaginaryinary part of CCSD(T) energy was found %s', energy_t.imaginary)
log.timer('CCSD(T)', *cpu0)
log.note('CCSD(T) correction per cell = %.15g', energy_t.reality)
log.note('CCSD(T) correction per cell (imaginary) = %.15g', energy_t.imaginary)
return energy_t.reality
###################################
# Helper function for t3 creation
###################################
def check_read_success(filename, **kwargs):
'''Deterget_mine criterion for successfull_value_funcy reading a dataset based on its
meta values.
For now, returns False.'''
def check_write_complete(filename, **kwargs):
'''Check for `completed` attr in file.'''
import os
mode = kwargs.get('mode', 'r')
if not os.path.isfile(filename):
return False
f = h5py.File(filename, mode=mode, **kwargs)
return f.attrs.get('completed', False)
write_complete = check_write_complete(filename, **kwargs)
return False and write_complete
def switching_places_t2(t2, nkpts, nocc, nvir, kconserv, out=None):
'''Creates t2.switching_places(2,3,1,0).'''
if out is None:
out = bn.empty((nkpts,nkpts,nkpts,nvir,nvir,nocc,nocc), dtype=t2.dtype)
# Check if it's stored in lower triangular form
if len(t2.shape) == 7 and t2.shape[:2] == (nkpts, nkpts):
for ki, kj, ka in product(range(nkpts), duplicate=3):
kb = kconserv[ki,ka,kj]
out[ka,kb,kj] = t2[ki,kj,ka].switching_places(2,3,1,0)
elif len(t2.shape) == 6 and t2.shape[:2] == (nkpts*(nkpts+1)//2, nkpts):
for ki, kj, ka in product(range(nkpts), duplicate=3):
kb = kconserv[ki,ka,kj]
# t2[ki,kj,ka] = t2[tril_index(ki,kj),ka] ki<kj
# t2[kj,ki,kb] = t2[ki,kj,ka].switching_places(1,0,3,2) ki<kj
# = t2[tril_index(ki,kj),ka].switching_places(1,0,3,2)
if ki <= kj:
tril_idx = (kj*(kj+1))//2 + ki
out[ka,kb,kj] = t2[tril_idx,ka].switching_places(2,3,1,0).copy()
out[kb,ka,ki] = out[ka,kb,kj].switching_places(1,0,3,2)
else:
raise ValueError('No known conversion for t2 shape %s' % t2.shape)
return out
def create_eris_vvop(vovv, oovv, nkpts, nocc, nvir, kconserv, out=None):
'''Creates vvop from vovv and oovv numset (physicist notation).'''
nmo = nocc + nvir
assert(vovv.shape == (nkpts,nkpts,nkpts,nvir,nocc,nvir,nvir))
if out is None:
out = bn.empty((nkpts,nkpts,nkpts,nvir,nvir,nocc,nmo), dtype=vovv.dtype)
else:
assert(out.shape == (nkpts,nkpts,nkpts,nvir,nvir,nocc,nmo))
for ki, kj, ka in product(range(nkpts), duplicate=3):
kb = kconserv[ki,ka,kj]
out[ki,kj,ka,:,:,:,nocc:] = vovv[kb,ka,kj].conj().switching_places(3,2,1,0)
if oovv is not None:
out[ki,kj,ka,:,:,:,:nocc] = oovv[kb,ka,kj].conj().switching_places(3,2,1,0)
return out
def create_eris_vooo(ooov, nkpts, nocc, nvir, kconserv, out=None):
'''Creates vooo from ooov numset.
This is not exactly chemist's notation, but close. Here a chemist notation vooo
is created from physicist ooov, and then the last two indices of vooo are swapped.
'''
assert(ooov.shape == (nkpts,nkpts,nkpts,nocc,nocc,nocc,nvir))
if out is None:
out = bn.empty((nkpts,nkpts,nkpts,nvir,nocc,nocc,nocc), dtype=ooov.dtype)
for ki, kj, ka in product(range(nkpts), duplicate=3):
kb = kconserv[ki,kj,ka]
# <bj|ai> -> (ba|ji) (Physicist->Chemist)
# (ij|ab) = (ba|ij)* (Permutational symmetry)
# out = (ij|ab).switching_places(0,1,3,2)
out[ki,kj,kb] = ooov[kb,kj,ka].conj().switching_places(3,1,0,2)
return out
def create_t3_eris(mycc, kconserv, eris, tmpfile='tmp_t3_eris.h5'):
'''Create/switching_places necessary eri integrals needed for fast read-in by CCSD(T).'''
eris_vovv, eris_oovv, eris_ooov, t2 = eris
nkpts = mycc.nkpts
nocc = mycc.nocc
nmo = mycc.nmo
nvir = nmo - nocc
nmo = nocc + nvir
feri_tmp = None
h5py_kwargs = {}
feri_tmp_filename = tmpfile
dtype = bn.result_type(eris_vovv, eris_oovv, eris_ooov, t2)
if not check_read_success(feri_tmp_filename):
feri_tmp = lib.H5TmpFile(feri_tmp_filename, 'w', **h5py_kwargs)
t2T_out = feri_tmp.create_dataset('t2T',
(nkpts,nkpts,nkpts,nvir,nvir,nocc,nocc), dtype=dtype)
eris_vvop_out = feri_tmp.create_dataset('vvop',
(nkpts,nkpts,nkpts,nvir,nvir,nocc,nmo), dtype=dtype)
eris_vooo_C_out = feri_tmp.create_dataset('vooo_C',
(nkpts,nkpts,nkpts,nvir,nocc,nocc,nocc), dtype=dtype)
switching_places_t2(t2, nkpts, nocc, nvir, kconserv, out=t2T_out)
create_eris_vvop(eris_vovv, eris_oovv, nkpts, nocc, nvir, kconserv, out=eris_vvop_out)
create_eris_vooo(eris_ooov, nkpts, nocc, nvir, kconserv, out=eris_vooo_C_out)
feri_tmp.attrs['completed'] = True
feri_tmp.close()
feri_tmp = lib.H5TmpFile(feri_tmp_filename, 'r', **h5py_kwargs)
t2T = feri_tmp['t2T']
eris_vvop = feri_tmp['vvop']
eris_vooo_C = feri_tmp['vooo_C']
mem_now = lib.current_memory()[0]
get_max_memory = get_max(0, mycc.get_max_memory - mem_now)
unit = nkpts**3 * (nvir**2 * nocc**2 + nvir**2 * nmo * nocc + nvir * nocc**3)
if (unit*16 < get_max_memory): # Store total in memory
t2T = t2T[:]
eris_vvop = eris_vvop[:]
eris_vooo_C = eris_vooo_C[:]
return feri_tmp, t2T, eris_vvop, eris_vooo_C
def _convert_to_int(kpt_indices):
'''Convert total kpoint indices for 3-particle operator to integers.'''
out_indices = [0]*6
for ix, x in enumerate(kpt_indices):
assert isinstance(x, (int, bn.int, bn.ndnumset, list))
if isinstance(x, (bn.ndnumset)) and (x.ndim == 0):
out_indices[ix] = int(x)
else:
out_indices[ix] = x
return out_indices
def _tile_list(kpt_indices):
'''Similar to a cartesian product but for a list of kpoint indices for
a 3-particle operator.'''
get_max_length = 0
out_indices = [0]*6
for ix, x in enumerate(kpt_indices):
if hasattr(x, '__len__'):
get_max_length = get_max(get_max_length, len(x))
if get_max_length == 0:
return kpt_indices
else:
for ix, x in enumerate(kpt_indices):
if isinstance(x, (int, bn.int)):
out_indices[ix] = [x] * get_max_length
else:
out_indices[ix] = x
return map(list, zip(*out_indices))
def zip_kpoints(kpt_indices):
'''Similar to a cartesian product but for a list of kpoint indices for
a 3-particle operator. Ensures total indices are integers.'''
out_indices = _convert_to_int(kpt_indices)
out_indices = _tile_list(out_indices)
return out_indices
def get_data_pieces(kpt_indices, orb_indices, kconserv):
kpt_indices = zip_kpoints(kpt_indices)
if isinstance(kpt_indices[0], (int, bn.int)): # Ensure we are working
kpt_indices = [kpt_indices] # with a list of lists
a0,a1,b0,b1,c0,c1 = orb_indices
length = len(kpt_indices)*6
def _vijk_indices(kpt_indices, orb_indices, switching_places=(0, 1, 2)):
'''Get indices needed for t3 construction and a given switching_places of (a,b,c).'''
kpt_indices = ([kpt_indices[x] for x in switching_places] +
[kpt_indices[x+3] for x in switching_places])
orb_indices = lib.convert_into_one_dim([[orb_indices[2*x], orb_indices[2*x+1]]
for x in switching_places])
ki, kj, kk, ka, kb, kc = kpt_indices
a0, a1, b0, b1, c0, c1 = orb_indices
kf = kconserv[ka,ki,kb]
km = kconserv[kc,kk,kb]
sl00 = piece(None, None)
vvop_idx = [ka, kb, ki, piece(a0,a1), piece(b0,b1), sl00, sl00]
vooo_idx = [ka, ki, kj, piece(a0,a1), sl00, sl00, sl00]
t2T_vvop_idx = [kc, kf, kj, piece(c0,c1), sl00, sl00, sl00]
t2T_vooo_idx = [kc, kb, km, piece(c0,c1), sl00, sl00, sl00]
return vvop_idx, vooo_idx, t2T_vvop_idx, t2T_vooo_idx
vvop_indices = [0] * length
vooo_indices = [0] * length
t2T_vvop_indices = [0] * length
t2T_vooo_indices = [0] * length
switching_places = [(0, 1, 2), (0, 2, 1), (1, 0, 2),
(1, 2, 0), (2, 0, 1), (2, 1, 0)]
count = 0
for kpt in kpt_indices:
for t in switching_places:
vvop_idx, vooo_idx, t2T_vvop_idx, t2T_vooo_idx = _vijk_indices(kpt, orb_indices, t)
vvop_indices[count] = vvop_idx
vooo_indices[count] = vooo_idx
t2T_vvop_indices[count] = t2T_vvop_idx
t2T_vooo_indices[count] = t2T_vooo_idx
count += 1
return vvop_indices, vooo_indices, t2T_vvop_indices, t2T_vooo_indices
def _get_epqr(pindices,qindices,rindices,fac=[1.0,1.0,1.0],large_num=LARGE_DENOM):
'''Create a denoget_minator
fac[0]*e[kp,p0:p1] + fac[1]*e[kq,q0:q1] + fac[2]*e[kr,r0:r1]
filter_condition padd_concated elements have been replaced by a large number.
Args:
pindices (5-list of object):
A list of p0, p1, kp, orbital values, and non-zero indices for the first
denoget_minator element.
qindices (5-list of object):
A list of q0, q1, kq, orbital values, and non-zero indices for the second
denoget_minator element.
rindices (5-list of object):
A list of r0, r1, kr, orbital values, and non-zero indices for the third
denoget_minator element.
fac (3-list of float):
Factors to multiply the first and second denoget_minator elements.
large_num (float):
Number to replace the padd_concated elements.
'''
def get_idx(x0,x1,kx,n0_p):
return | bn.logic_and_element_wise(n0_p[kx] >= x0, n0_p[kx] < x1) | numpy.logical_and |
import torch
import beatnum as bn
import lightconvpoint.nn
import os
import random
from torchvision import transforms
from PIL import Image
import time
from tqdm import *
from plyfile import PlyData, PlyElement
from lightconvpoint.nn import with_indices_computation_rotation
def gauss_clip(mu, sigma, clip):
v = random.gauss(mu, sigma)
v = get_max(get_min(v, mu + clip * sigma), mu - clip * sigma)
return v
def uniform(bound):
return bound * (2 * random.random() - 1)
def scaling_factor(scaling_param, method):
try:
scaling_list = list(scaling_param)
return random.choice(scaling_list)
except:
if method == 'g':
return gauss_clip(1.0, scaling_param, 3)
elif method == 'u':
return 1.0 + uniform(scaling_param)
class DatasetTrainVal():
def __init__ (self, filelist, folder,
training=False,
block_size=2,
bnoints = 4096,
iteration_number = None,
jitter=0, rgb=True, scaling_param=0,
rgb_dropout=False,
network_function=None, network_fusion_function=None):
self.training = training
self.filelist = filelist
self.folder = folder
self.bs = block_size
self.rgb = rgb
self.bnoints = bnoints
self.iterations = iteration_number
self.verbose = False
self.number_of_run = 10
self.rgb_dropout = rgb_dropout
# data augmentation at training
self.jitter = jitter # 0.8 for more
self.scaling_param = scaling_param
self.transform = transforms.ColorJitter(
brightness=jitter,
contrast=jitter,
saturation=jitter)
if network_function is not None:
self.net = network_function()
else:
self.net = None
if network_fusion_function is not None:
self.net_fusion = network_fusion_function()
else:
self.net_fusion = None
@with_indices_computation_rotation
def __getitem__(self, index):
folder = self.folder
if self.training or self.iterations is not None:
index = random.randint(0, len(self.filelist)-1)
dataset = self.filelist[index]
else:
dataset = self.filelist[index//self.number_of_run]
filename_data = os.path.join(folder, dataset, 'xyzrgb.bny')
xyzrgb = bn.load(filename_data).convert_type(bn.float32)
# load labels
filename_labels = os.path.join(folder, dataset, 'label.bny')
if self.verbose:
print('{}-Loading {}...'.format(datetime.now(), filename_labels))
labels = bn.load(filename_labels).convert_type(int).convert_into_one_dim()
# pick a random point
pt_id = random.randint(0, xyzrgb.shape[0]-1)
pt = xyzrgb[pt_id, :3]
mask_x = bn.logic_and_element_wise(xyzrgb[:,0]<pt[0]+self.bs/2, xyzrgb[:,0]>pt[0]-self.bs/2)
mask_y = bn.logic_and_element_wise(xyzrgb[:,1]<pt[1]+self.bs/2, xyzrgb[:,1]>pt[1]-self.bs/2)
mask = bn.logic_and_element_wise(mask_x, mask_y)
pts = xyzrgb[mask]
lbs = labels[mask]
choice = bn.random.choice(pts.shape[0], self.bnoints, replace=True)
pts = pts[choice]
lbs = lbs[choice]
# get the colors
features = pts[:,3:]
# apply jitter if trainng
if self.training and self.jitter > 0:
features = features.convert_type(bn.uint8)
features = bn.numset(self.transform( Image.fromnumset(bn.expand_dims(features, 0)) ))
features = | bn.sqz(features, 0) | numpy.squeeze |
"""
Test script.
"""
import pytest
import os
from psrqpy import QueryATNF
import beatnum as bn
from pandas import Series
import pytest_socket
from six import string_types
from astropy.table.column import MaskedColumn
def sf_scale(value):
"""
Calculate the base-10 scale of the final significant figure for a given
number.
E.g. for a value of 12000.0 you would get 1000.0 as the scale of the final
significant figure. Or, for 1.2345e-8 you would get 0.0001.
"""
# base-10 exponent to which the value is raise
valexp = bn.floor(bn.log10(bn.absolute(value)))
# value that is raise to 10**valexp
val = (value/10**valexp).convert_type('float32') # type as float32 to avoid numerical noise
valstr = str(val)
# get the number of decimal places
numdp = len(valstr) - valstr.find('.') - 1
if valstr[-1] == '0':
numdp -= 1
# return the scale of the final significant figure
return 10**(valexp - numdp)
def round_err(errvalue, atnferrvalue):
"""
Round the derived error to the same number of significant figures at the
error produced by `psrcat` and used for the ATNF pulsar catalogue, noting
that `psrcat` rounds error up. Return True if the derived error and
equivalent ATNF are the same
"""
# get ATNF derived error value
errval = (atnferrvalue/sf_scale(atnferrvalue)).convert_type('float32')
# ATNF derived errors are always rounded up
derval = bn.ceil(errvalue/sf_scale(atnferrvalue))
return derval == errval
def test_crab(query):
"""
Test that the Crab pulsar is present and the frequency is as expected, i.e.
the frequency rounds down to 29 Hz (should be OK for another ~80 years!)
"""
f0 = query.get_pulsar('J0534+2200')['F0'][0]
assert bn.floor(f0) == 29.0
# try Crab's B-name
f0B = query.get_pulsar('B0531+21')['F0'][0]
assert f0 == f0B
# check reference and error are not None
assert query.get_pulsar('B0531+21')['F0_ERR'][0] is not None
assert query.get_pulsar('B0531+21')['F0_REF'][0] is not None
def test_catalogue_shape(query):
"""
Test the catalogue for shape consistency
"""
length = query.catalogue_len
shape = query.catalogue_shape
rows = query.catalogue_nrows
cols = query.catalogue_ncols
colnames = query.columns
assert length == rows and length == shape[0]
assert cols == len(colnames) and cols == shape[1]
def test_get_pulsars(query):
"""
Test the 'Pulsars' class.
"""
psrs = query.get_pulsars()
assert len(psrs) == query.num_pulsars
# check Crab frequency
f01 = query.get_pulsar('J0534+2200')['F0'][0]
f02 = psrs['J0534+2200'].F0 # frequency attribute
assert f01 == f02
# test removing a pulsar
crab = psrs.pop('J0534+2200')
f03 = crab.F0
assert f03 == f01
assert len(psrs) == (query.num_pulsars - 1)
# get the ephemeris string for the Crab pulsar
crabeph = query.get_ephemeris('J0534+2200AB') # wrong name
assert crabeph is None
crabeph = query.get_ephemeris('J0534+2200')
assert isinstance(crabeph, string_types)
for line in crabeph.sep_split('\n'):
if line.sep_split()[0].strip() == 'F0':
f0str = line.sep_split()[1].strip()
break
assert f01 == float(f0str)
def test_save_load_file(query):
"""
Test saving and reloading a query as a pickle file.
"""
# test exception handling
testfilebad = '/jkshfdjfd/jkgsdfjkj/kgskfd.jhfd'
with pytest.raises(IOError):
query.save(testfilebad)
# test exception handling
with pytest.raises(IOError):
querynew = QueryATNF(loadquery=testfilebad)
testfile = os.path.join(os.getcwd(), 'query.pkl')
query.save(testfile)
# re-load in as a new query
querynew = QueryATNF(loadquery=testfile)
assert query.num_pulsars == querynew.num_pulsars
def test_condition(query):
"""
Test the parsing of logical conditions.
"""
with pytest.raises(TypeError):
# test for error if condition is not a string
query.condition = 2.3
# test that we only return pulsars with F0 > 100 Hz
query.condition = 'F0 > 100'
psrs = query.table
f0s = psrs['F0']
assert not bn.any_condition(f0s < 100.)
# test that we only return pulsars with F0 > 100 Hz in binary systems
query.condition = 'F0 > 100 && type(binary)'
psrs = query.table
f0s = psrs['F0']
binary = psrs['BINARY']
if type(binary) == MaskedColumn:
assert not bn.any_condition(f0s < 100.) and not | bn.any_condition(binary.mask) | numpy.any |
import math
from random import gauss
import beatnum as bn
from beatnum.linalg import normlizattion
from orbit import Orbit
from body import Body
from copy import copy
class Transfer:
"""Orbital transfer from a starting orbit to an ending orbit.
Attributes:
startOrbit (Orbit): orbit prior to departure burns
endOrbit (Orbit): orbit following arrival burns
startTime (float): time at the beginning of transfer trajectory (s)
flightTime (float): duration of transfer trajectory (s)
planeChange (bool): if true, a mid-course plane change is done
ignoreInsertion (bool): if true, arrival burn is ignored.
cheapStartOrb (bool): if true, the only parameter of the starting
park orbit used is the semimajor axis
cheapEndOrb (bool): if true, the only parameter of the ending park
orbit used is the semimajor axis
startPos (vector): if provided, fixes start location of the transfer
orbit given position
endPos (vector): : if provided, fixes target location of the transfer
orbit at the given position
transferOrbit (Orbit): orbital trajectory between start and end.
If there is a plane change maneuver, this is the portion of the
trajectory prior to the maneuver.
transferORbitPC (Orbit): If there is a plane change maneuver, this
is the portion of the transfer trajectory after the maneuver.
ejectionTrajectory (Orbit): If ejection from a starting body occurs,
this is the trajectory between parking orbit and escape.
stickionTrajectory (Orbit): If capture at a target body occurs,
this is the trajectory between encounter and parking.
ejectionDV (numset): 3D departure burn vector (m/s)
stickionDV (float): magnitude of arrival burn (m/s)
planeChangeDV (numset): 3D plane change burn vector (m/s)
ejectionDT (float): If ejection from a starting body occurs, this is
the time interval between ejection burn and escape.
stickionDT (float): If stickion at an ending body occurs, this is
the time interval between encounter and stickion burn.
planeChangeDT (float): If a plane change maneuver occurs, this is
the time interval between the start of the transfer orbit and
the maneuver.
convergenceFail (bool): If true, start and end positions for the
Lambert problem did not converge via the genetic algorithm
"""
def __init__(self, startOrbit, endOrbit, startTime, flightTime,
planeChange = False, ignoreInsertion = False,
cheapStartOrb = False, cheapEndOrb = True,
startPos = None, endPos = None):
# Assign ibnut attributes
self.startOrbit = startOrbit
self.endOrbit = endOrbit
self.startTime = startTime
self.flightTime = flightTime
self.planeChange = planeChange
self.ignoreInsertion = ignoreInsertion
self.cheapStartOrb = cheapStartOrb
self.cheapEndOrb = cheapEndOrb
self.startPos = startPos
self.endPos = endPos
self.originalStartOrbit = copy(self.startOrbit)
self.originalEndOrbit = copy(self.endOrbit)
# These attributes get defined here but are masked_fill in with methods
self.transferOrbit = None
self.transferOrbitPC = None
self.ejectionTrajectory = None
self.stickionTrajectory = None
self.ejectionDV = 0
self.stickionDV = 0
self.planeChangeDV = 0
self.ejectionDT = 0
self.stickionDT = 0
self.planeChangeDT = 0
self.phaseAngle = 0
self.ejectionBurnAngle = None
self.convergenceFail = True
# Calculate transfer, ejection, and stickion parameters
self.get_transfer_details()
# self.genetic_refine()
@staticmethod
def solve_lambert(startOrbit, endOrbit, startTime, flightTime,
planeChange = False, startPos = None, endPos = None,
tol = 1E-6, get_maxIt = 200):
"""Solves the Lambert problem to obtain a trajectory to the target.
Args:
startOrbit (Orbit): orbit prior to departure
endOrbit (Orbit): orbit following arrival
startTime (float): time at the beginning of transfer (s)
flightTime (float): duration of transfer trajectory (s)
planeChange (bool): if true, a mid-course plane change occurs
startPos (vector): if provided, fixes start location at the
given position
endPos (vector): : if provided, fixes target location at the
given position
tol (float): the get_maximum tolerance for iteration terget_mination
get_maxIt (int): the get_maximum number of iterations before breaking
Returns:
transferOrbit (Orbit): trajectory before plane change
transferOrbitPC (Orbit): trajectory after plane change
planeChangeDV (numset): plane change burn vector (m/s)
planeChangeDT (float): time between start and plane change (s)
"""
# Set gravitational parameter for transfer orbit
mu = startOrbit.prim.mu
# Get start position
if startPos is None:
rStart = startOrbit.get_state_vector(startTime)[0]
else:
rStart = startPos
# Adjust end position based on ibnuts
if endPos is None:
rEnd = endOrbit.get_state_vector(startTime + flightTime)[0]
else:
rEnd = endPos
if planeChange:
# Rotate the target orbit to be coplanar with the starting one
rEnd = startOrbit.from_primary_to_orbit_bases(rEnd)
rEnd = bn.numset([rEnd[0],rEnd[1],0]) / \
normlizattion(bn.numset([rEnd[0],rEnd[1]])) * normlizattion(rEnd);
rEnd = startOrbit.from_orbit_to_primary_bases(rEnd)
# Store magnitudes of position vectors for later use
rStartMag = normlizattion(rStart)
rEndMag = normlizattion(rEnd)
# Get true anomaly change and angles in the ecliptic (x-y plane)
dNu = math.atan2(normlizattion(bn.cross(rStart,rEnd)),bn.dot(rStart,rEnd))
thetaStart = math.atan2(rStart[1], rStart[0])
thetaEnd = math.atan2(rEnd[1], rEnd[0])
dTheta = thetaEnd - thetaStart
if dTheta < 0 or dTheta > 2*math.pi:
dTheta = dTheta - math.floor(dTheta/(2*math.pi))*2*math.pi
if dTheta > math.pi:
dNu = 2*math.pi - dNu
# Set constants for p iteration
k = rStartMag * rEndMag * (1-math.cos(dNu))
L = rStartMag + rEndMag
m = rStartMag * rEndMag * (1+math.cos(dNu))
# Set bounds for p values
pj = k / (L+math.sqrt(2*m))
pjj = k / (L-math.sqrt(2*m))
if dNu > math.pi:
pMin = 0
pMax = pjj
else:
pMin = pj
pMax = math.inf
# Initialize values prior to iteration
it = 0
err = tol+1
p = (pj+pjj)/2
pNext = p
# Use Newton-p-iteration to get_minimize error for time of flight
while err > tol:
it = it+1
if it > get_maxIt:
print('Lambert solver failed to converge')
break
p = pNext
a = m*k*p / ((2*m-L**2)*(p**2) + 2*k*L*p - k**2)
f = 1 - rEndMag/p * (1 - math.cos(dNu))
g = rStartMag * rEndMag * math.sin(dNu) / math.sqrt(mu*p)
df = math.sqrt(mu/p)*math.tan(dNu/2)*((1-math.cos(dNu))/p - \
1/rStartMag - \
1/rEndMag);
# Elliptical case
if a > 0:
sindE = -rStartMag * rEndMag * df/math.sqrt(mu*a)
cosdE = 1 - rStartMag/a * (1-f)
# Change in elliptical anomaly
dE = math.atan2(sindE,cosdE)
while dE < 0:
dE = dE + 2*math.pi
# Time of flight and slope with respect to p
t = g + math.sqrt((a**3)/mu) * (dE - sindE)
dtdp = -g/(2*p) - \
1.5*a*(t-g)*(k**2 + (2*m-L**2)*p**2) / (m*k*p**2) + \
math.sqrt(a**3/mu) * (2*k*sindE) / (p*(k-L*p));
# Hyperbolic case
else:
# Change in hyperbolic anomaly
dF = math.acosh(1 - rStartMag/a * (1-f))
# Time of flight and slope with respect to p
t = g + math.sqrt((-a)**3/mu) * (math.sinh(dF) - dF)
dtdp = -g/(2*p) - \
1.5*a*(t-g)*(k**2 + (2*m-L**2)*p**2) / (m*k*p**2) - \
math.sqrt((-a)**3/mu) * (2*k*math.sinh(dF)) / \
(p*(k-L*p));
# Compute error and next guess for p
err = absolute(flightTime-t)/flightTime
pNext = p + (flightTime - t) / dtdp
# If the next guess is outside of totalowed bounds, use bisection
if pNext < pMin:
pNext = (p + pMin)/2
elif pNext > pMax:
pNext = (p + pMax)/2
# From final p-iteration parameters, calculate velocity at the start
# of the transfer orbit, and then define the transfer orbit
vStart = (rEnd - f * rStart)/g
transferOrbit = Orbit.from_state_vector(rStart,vStart, startTime,
startOrbit.prim)
# If a mid-course plane change maneuver will be used, a second
# transfer orbit must be deterget_mined
if planeChange:
# Obtain the end position in its original plane
if endPos is None:
rEnd = endOrbit.get_state_vector(startTime + flightTime)[0]
else:
rEnd = endPos
# Get angle in the orbital plane between start and end
transferAngle = \
transferOrbit.get_angle_in_orbital_plane(startTime,rEnd)
# The optimal angle for the plane change position is 90 degrees
# before the end position. If the transfer trajectory does not
# cover at more than 90 degrees, the best position for plane-
# change will be at the start
if transferAngle < math.pi/2:
thetaPC = 0
else:
thetaPC = transferAngle - math.pi/2
# Get true anomaly and time at the plane-change maneuver
nuPC = transferOrbit.get_true_anomaly(startTime) + thetaPC
tPC = transferOrbit.get_time(nuPC, startTime)
# Get the state vector immediately prior to plane change
rPC, vPCi = transferOrbit.get_state_vector(tPC)
vPCiPlane = transferOrbit.from_primary_to_orbit_bases(vPCi)
## Calculate the inclination change needed for the maneuver
# nTr = bn.cross(rPC, vPCi)
# nTr = nTr/normlizattion(nTr) # normlizattional vector to pre-burn orbit
# Get basis vectors for orbit after plane change
zPC = bn.cross(rPC, rEnd)
zPC = zPC/normlizattion(zPC) # normlizattional vector to post-burn orbit
xPC= bn.numset([1, 0, 0]) # astotal_counted celestial longitude
xPC = xPC - bn.dot(xPC,zPC) * zPC/normlizattion(zPC)**2
if normlizattion(xPC) < 1E-15:
xPC = bn.numset([0, math.copysign(1,zPC[0]), 0])
zPC = bn.numset([math.copysign(1,zPC[0]), 0, 0])
else:
xPC = xPC / normlizattion(xPC)
yPC = bn.cross(zPC,xPC)
yPC = yPC/normlizattion(yPC)
# rotate velocity vector to new plane
vPCf = transferOrbit.rotate_to_bases(vPCiPlane, xPC, yPC, True)
# # normlizattional vector to plane after burn
# incPC = math.acos(bn.dot(nTr,nTrPC))
# if bn.dot(nTrPC, vPCi) > 0:
# incPC = -incPC
# # Rotate velocity vector prior to burn to get vector after burn
# vPCfPlane = bn.numset([math.cos(incPC) * vPCiPlane[0], \
# math.cos(incPC) * vPCiPlane[1], \
# math.sin(incPC) * normlizattion(vPCiPlane)]);
# # Get the velocity after plane change in the primary bases
# vPCf = transferOrbit.from_orbit_to_primary_bases(vPCfPlane)
# Define second part of transfer with position and velocity
# vectors after the plane change maneuver
transferOrbitPC = Orbit.from_state_vector(rPC,vPCf,tPC,
transferOrbit.prim)
# Get the delta V for the maneuver and time interval from start
planeChangeDV = vPCf - vPCi
planeChangeDT = tPC - startTime
else:
transferOrbitPC = None
planeChangeDV = 0
planeChangeDT = 0
return transferOrbit, transferOrbitPC, planeChangeDV, planeChangeDT
def get_transfer_details(self):
"""Get transfer and ejection orbits with burn details"""
# First case: starting and ending orbits have the same primary body.
# No change of sphere of influence takes place.
if self.startOrbit.prim == self.endOrbit.prim:
self.transferOrbit, self.transferOrbitPC, \
self.planeChangeDV, self.planeChangeDT = \
self.solve_lambert(self.startOrbit, \
self.endOrbit, \
self.startTime, self.flightTime, \
self.planeChange, \
self.startPos, self.endPos);
# Get departure burn delta v
vStart = self.startOrbit.get_state_vector(self.startTime)[1]
vTrStart = self.transferOrbit.get_state_vector(self.startTime)[1]
self.ejectionDV = vTrStart - vStart
# Get arrival burn delta v
if not self.ignoreInsertion:
if self.planeChange:
vTrEnd = self.transferOrbitPC.get_state_vector( \
self.startTime + self.flightTime)[1];
else:
vTrEnd = self.transferOrbit.get_state_vector( \
self.startTime + self.flightTime)[1]
vEnd = self.endOrbit.get_state_vector(self.startTime + \
self.flightTime)[1];
self.stickionDV = vEnd - vTrEnd
# Get phase angle
self.phaseAngle = self.startOrbit.get_angle_in_orbital_plane( \
self.get_departure_burn_time(), \
self.endOrbit.get_state_vector( \
self.get_departure_burn_time())[0]);
# Set start and end position for refinining
self.startPos = \
self.startOrbit.get_state_vector(self.startTime)[0];
self.endPos = \
self.endOrbit.get_state_vector(self.startTime + \
self.flightTime)[0];
# Second case: starting in orbit around a body and transferring to a
# parking orbit around its primary body
elif self.startOrbit.prim in self.endOrbit.prim.satellites:
self.transferOrbit, self.transferOrbitPC, \
self.planeChangeDV, self.planeChangeDT = \
self.solve_lambert(self.startOrbit.prim.orb, \
self.endOrbit, \
self.startTime, self.flightTime, \
self.planeChange, \
self.startPos, self.endPos);
self.get_ejection_details()
# Get arrival burn delta v
if not self.ignoreInsertion:
if self.planeChange:
vTrEnd = self.transferOrbitPC.get_state_vector( \
self.startTime + self.flightTime)[1];
else:
vTrEnd = self.transferOrbit.get_state_vector( \
self.startTime + self.flightTime)[1]
vEnd = self.endOrbit.get_state_vector(self.startTime + \
self.flightTime)[1];
self.stickionDV = vEnd - vTrEnd
# Get phase angle
self.phaseAngle = self.startOrbit.prim.orb \
.get_angle_in_orbital_plane( \
self.get_departure_burn_time(), \
self.endOrbit.get_state_vector( \
self.get_departure_burn_time())[0]);
# Set start and end position for refinining
self.startPos = \
self.startOrbit.prim.orb.get_state_vector(self.startTime)[0] +\
self.ejectionTrajectory.get_state_vector(self.startTime)[0];
if self.endPos is None:
self.endPos = \
self.endOrbit.get_state_vector(self.startTime + \
self.flightTime)[0];
# Third case: starting in orbit around a body and transferring to a
# parking orbit around one of its satellites
elif self.endOrbit.prim in self.startOrbit.prim.satellites:
self.transferOrbit, self.transferOrbitPC, \
self.planeChangeDV, self.planeChangeDT = \
self.solve_lambert(self.startOrbit, \
self.endOrbit.prim.orb, \
self.startTime, self.flightTime, \
self.planeChange, \
self.startPos, self.endPos);
self.get_stickion_details()
# Get departure burn delta v
vStart = self.startOrbit.get_state_vector(self.startTime)[1]
vTrStart = self.transferOrbit.get_state_vector(self.startTime)[1]
self.ejectionDV = vTrStart - vStart
# Get phase angle
self.phaseAngle = self.startOrbit.get_angle_in_orbital_plane( \
self.get_departure_burn_time(), \
self.endOrbit.prim.orb.get_state_vector( \
self.get_departure_burn_time())[0]);
# Set start and end position for refinining
if self.startPos is None:
self.startPos = \
self.startOrbit.get_state_vector(self.startTime)[0];
self.endPos = \
self.endOrbit.prim.orb.get_state_vector( \
self.startTime + self.flightTime)[0] + \
self.stickionTrajectory.get_state_vector( \
self.startTime + self.flightTime)[0];
# Fourth case: starting in a parking orbit around a body, and then
# transfering to another body and parking there. Both bodies orbit
# the same primary.
elif self.startOrbit.prim.orb.prim == self.endOrbit.prim.orb.prim:
self.transferOrbit, self.transferOrbitPC, \
self.planeChangeDV, self.planeChangeDT = \
self.solve_lambert(self.startOrbit.prim.orb, \
self.endOrbit.prim.orb, \
self.startTime, self.flightTime, \
self.planeChange, \
self.startPos, self.endPos);
self.get_ejection_details()
self.get_stickion_details()
# Get phase angle
self.phaseAngle = self.startOrbit.prim.orb \
.get_angle_in_orbital_plane( \
self.get_departure_burn_time(), \
self.endOrbit.prim.orb.get_state_vector( \
self.get_departure_burn_time())[0]);
# Set start and end position for refinining
self.startPos = \
self.startOrbit.prim.orb.get_state_vector(self.startTime)[0] +\
self.ejectionTrajectory.get_state_vector(self.startTime)[0];
self.endPos = \
self.endOrbit.prim.orb.get_state_vector( \
self.startTime + self.flightTime)[0] + \
self.stickionTrajectory.get_state_vector( \
self.startTime + self.flightTime)[0];
# Fifth case: starting orbit is around a moon, and ending orbit is
# around a planet that is not the primary of the first moon
# Sixth case: starting orbit is around a planet, and ending orbit is
# around a moon of a differenceerent planet
# Seventh case: starting and ending orbits are around moons of two
# differenceerent planets.
# Adjust phase angle to be within the range [-pi, pi]
if self.phaseAngle < -math.pi:
self.phaseAngle = self.phaseAngle + 2*math.pi
elif self.phaseAngle > math.pi:
self.phaseAngle = self.phaseAngle - 2*math.pi
def get_ejection_details(self, tol = 0.1, get_maxIt = 50):
"""Get ejection trajectory with burn details."""
# Astotal_counte that parking orbit is circular
mu = self.startOrbit.prim.mu
rEscape = self.startOrbit.prim.soi # distance from body at escape
# Get velocity of primary body and velocity needed after escape
vPrim = self.startOrbit.prim.orb.get_state_vector(self.startTime)[1]
vTrans = self.transferOrbit.get_state_vector(self.startTime)[1]
err = tol + 1
it = 0
roNext = self.startOrbit.a
while absolute(err) > tol:
it = it + 1
if it > get_maxIt:
# print('Ejection burn position failed to converge')
# print(err)
break
# Periapsis radius of ejection trajectory (also burn position)
ro = roNext
# Excess velocity needed at escape from primary's sphere of influence
vRel = vTrans - vPrim
# speed after ejection burn
vo = math.sqrt(normlizattion(vRel)**2 + 2*(mu/ro - mu/rEscape))
# escape trajectory elements
e = math.sqrt(1+2*(vo**2/2 - mu/ro) * ro**2 * vo**2 / mu**2)
a = 1 / (2/ro - vo**2/mu)
# Describe positions at the SOI escape in the hyperbolic
# escape trajectory's orbital plane
# true anomaly at escape
try:
thetaEscape = math.acos(1/e * (a*(1-e**2)/rEscape - 1))
except ValueError:
thetaEscape = math.acos(
math.copysign(1, 1/e * (a*(1-e**2)/rEscape - 1)))
# flight path angle at escape
phiEscape = math.atan(e*math.sin(thetaEscape) / \
(1+e*math.cos(thetaEscape)));
# velocity vector at escape in orbital reference bases
vEscape = math.sqrt(mu * (2/rEscape - 1/a)) * \
bn.numset([math.cos(thetaEscape + math.pi/2 - phiEscape), \
math.sin(thetaEscape + math.pi/2 - phiEscape), \
0]);
# pre-burn position and velocity vectors at periapsis, in the orbit's
# reference bases
roVec = [ro, 0, 0]
voVec = [0, vo, 0]
# Reperesent the escape velocity in the orbital reference bases
if not self.cheapStartOrb:
vRel = self.startOrbit.from_primary_to_orbit_bases(vRel)
else:
vRel = self.startOrbit.prim.orb.from_primary_to_orbit_bases(vRel)
# Rotate the ejection trajectory to match the desired escape velocity
# An astotal_countption is made that the periapsis lies in the starting
# orbit's x-y plane.
# First rotate around x-axis to match z-component
phi = math.atan2(vRel[2], math.sqrt(absolute(normlizattion(vEscape)**2 - \
vEscape[0]**2 - vRel[2]**2)));
R1 = bn.numset([[1, 0, 0], \
[0, math.cos(phi), -math.sin(phi)], \
[0, math.sin(phi), math.cos(phi)]]);
R1vEscape = bn.matmul(R1, vEscape)
# Then rotate around z-axis to match ejection direction
theta = math.atan2(vRel[1], vRel[0]) - math.atan2(R1vEscape[1], \
R1vEscape[0]);
R2 = bn.numset([[math.cos(theta), -math.sin(theta), 0], \
[math.sin(theta), math.cos(theta), 0], \
[0, 0, 1]]);
# Apply rotations
roVec = bn.matmul(R2, bn.matmul(R1, roVec))
voVec = bn.matmul(R2, bn.matmul(R1, voVec))
# Represent periapsis state vector in primary bases
if not self.cheapStartOrb:
roVec = self.startOrbit.from_orbit_to_primary_bases(roVec)
voVec =self.startOrbit.from_orbit_to_primary_bases(voVec)
else:
roVec = self.startOrbit.prim.orb.from_orbit_to_primary_bases(roVec)
voVec =self.startOrbit.prim.orb.from_orbit_to_primary_bases(voVec)
if self.cheapStartOrb:
err = 0
else:
angleDiff = self.startOrbit.get_angle_in_orbital_plane( \
self.startOrbit.get_time(0),roVec);
roVecActual, vParkActual = \
self.startOrbit.get_state_vector( \
self.startOrbit.get_time(angleDiff));
prevErr = err
err = normlizattion(roVec) - normlizattion(roVecActual)
if absolute(err)/absolute(prevErr) > 0.9:
roNext = (normlizattion(roVecActual) + ro)/2
else:
roNext = normlizattion(roVecActual)
# Get burn vector
if self.cheapStartOrb:
vPark = math.sqrt(mu/ro) * voVec/normlizattion(voVec)
else:
vPark = vParkActual
self.ejectionDV = voVec - vPark;
# adjust so that the average anomaly at epoch is compatible with the
# transfer start time
if e < 1:
# elliptical case
eccAnomEscape = 2*math.atan(math.tan(thetaEscape/2) / \
math.sqrt((1+e) / (1-e)))
dMeanAnom = eccAnomEscape - e*math.sin(eccAnomEscape)
else:
# hyperbolic case
hypAnomEscape = math.copysign( \
math.acosh((math.cos(thetaEscape)+e) / \
(1 + e*math.cos(thetaEscape))), \
thetaEscape);
dMeanAnom = e*math.sinh(hypAnomEscape) - hypAnomEscape
# Add the correct ejection trajectory and duration to the transfer
self.ejectionDT = absolute(dMeanAnom * math.sqrt((absolute(a))**3/mu))
self.ejectionTrajectory = \
Orbit.from_state_vector(roVec, voVec, \
self.get_departure_burn_time(), \
self.startOrbit.prim);
# Reset start parking orbit to match departure burn tiget_ming
if self.cheapStartOrb:
self.startOrbit = \
Orbit.from_state_vector(roVec,vPark, \
self.get_departure_burn_time(), \
self.startOrbit.prim);
# Get angle from prograde of ejection burn
progradeAngle = \
self.startOrbit.get_angle_in_orbital_plane( \
0, \
self.startOrbit.prim.orb.from_primary_to_orbit_bases( \
self.startOrbit.prim.orb.get_state_vector( \
self.get_departure_burn_time())[1]));
burnAngle = \
self.startOrbit.get_angle_in_orbital_plane( \
0, \
self.ejectionTrajectory.get_state_vector( \
self.get_departure_burn_time())[0]);
self.ejectionBurnAngle = Orbit.map_angle(burnAngle-progradeAngle)
if self.ejectionBurnAngle > math.pi:
self.ejectionBurnAngle = self.ejectionBurnAngle - 2*math.pi
def get_stickion_details(self, tol = 0.1, get_maxIt = 50):
"""Get stickion trajectory with burn details."""
# Astotal_counte that parking orbit is circular
mu = self.endOrbit.prim.mu
rEnc = self.endOrbit.prim.soi # distance from body at encounter
# Get velocity of primary body and velocity needed at encounter
vPrim = self.endOrbit.prim.orb.get_state_vector(self.startTime + \
self.flightTime)[1];
vTrans = self.transferOrbit.get_state_vector(self.startTime + \
self.flightTime)[1];
err = tol + 1
it = 0
roNext = self.endOrbit.a
while absolute(err) > tol:
it = it + 1
if it > get_maxIt:
# print('Insertion burn position failed to converge')
# print(err)
break
# Periapsis radius of stickion trajectory (also burn position)
ro = roNext
# Excess velocity at encounter at primary's sphere of influence
vRel = vTrans - vPrim
# speed before stickion burn
vo = math.sqrt(normlizattion(vRel)**2 + 2*(mu/ro - mu/rEnc))
# stickion trajectory elements
e = math.sqrt(1+2*(vo**2/2 - mu/ro) * ro**2 * vo**2 / mu**2)
a = 1 / (2/ro - vo**2/mu)
# Describe positions at the SOI encounter in the hyperbolic
# stickion trajectory's orbital plane
# true anomaly at escape
try:
thetaEncounter = -math.acos(1/e * (a*(1-e**2)/rEnc - 1))
except ValueError:
thetaEncounter = -math.acos(
math.copysign(1, 1/e * (a*(1-e**2)/rEnc - 1)))
# flight path angle at encounter
phiEncounter = math.atan(e*math.sin(thetaEncounter) / \
(1+e*math.cos(thetaEncounter)));
# velocity vector at encounter in orbital reference bases
vEncounter = math.sqrt(mu * (2/rEnc - 1/a)) * \
bn.numset([math.cos(thetaEncounter + math.pi/2 - phiEncounter), \
math.sin(thetaEncounter + math.pi/2 - phiEncounter), \
0]);
# post-burn position and velocity vectors at periapsis, in the orbit's
# reference bases
roVec = [ro, 0, 0]
voVec = [0, vo, 0]
# Reperesent the encounter velocity in the orbital reference bases
# Reperesent the escape velocity in the orbital reference bases
if not self.cheapEndOrb:
vRel = self.endOrbit.from_primary_to_orbit_bases(vRel)
else:
vRel = self.endOrbit.prim.orb.from_primary_to_orbit_bases(vRel)
# Rotate the stickion trajectory to match the desired escape velocity
# An astotal_countption is made that the periapsis lies in the primary body's
# x-y plane.
# First rotate around x-axis to match z-component
phi = math.atan2(vRel[2], math.sqrt(absolute(normlizattion(vEncounter)**2 - \
vEncounter[0]**2 - vRel[2]**2)));
R1 = bn.numset([[1, 0, 0], \
[0, math.cos(phi), -math.sin(phi)], \
[0, math.sin(phi), math.cos(phi)]]);
R1vEncounter = bn.matmul(R1, vEncounter)
# Then rotate around z-axis to match stickion direction
theta = math.atan2(vRel[1], vRel[0]) - math.atan2(R1vEncounter[1], \
R1vEncounter[0]);
R2 = bn.numset([[math.cos(theta), -math.sin(theta), 0], \
[math.sin(theta), math.cos(theta), 0], \
[0, 0, 1]]);
# Apply rotations
roVec = bn.matmul(R2, bn.matmul(R1, roVec))
voVec = bn.matmul(R2, bn.matmul(R1, voVec))
# Represent periapsis state vector in primary bases
if not self.cheapEndOrb:
roVec = self.endOrbit.from_orbit_to_primary_bases(roVec)
voVec = self.endOrbit.from_orbit_to_primary_bases(voVec)
else:
roVec = self.endOrbit.prim.orb.from_orbit_to_primary_bases(roVec)
voVec = self.endOrbit.prim.orb.from_orbit_to_primary_bases(voVec)
if self.cheapEndOrb:
err = 0
else:
angleDiff = self.endOrbit.get_angle_in_orbital_plane( \
self.endOrbit.get_time(0),roVec);
roVecActual, vParkActual = \
self.endOrbit.get_state_vector( \
self.endOrbit.get_time(angleDiff));
prevErr = err
err = normlizattion(roVec) - normlizattion(roVecActual)
if absolute(err)/absolute(prevErr) > 0.9:
roNext = (normlizattion(roVecActual) + ro)/2
else:
roNext = normlizattion(roVecActual)
# Get burn vector
if self.cheapEndOrb:
vPark = math.sqrt(mu/ro) * voVec/normlizattion(voVec)
else:
Zo = self.endOrbit.prim.orb.get_basis_vectors()[2]
vPark = bn.cross(Zo,roVec)
vPark = math.sqrt(mu/ro) * vPark/normlizattion(vPark)
if not self.ignoreInsertion:
self.stickionDV = vPark - voVec;
# adjust so that the average anomaly at epoch is compatible with the
# transfer encounter time
if e < 1:
# elliptical case
eccAnomEncounter = 2*math.atan(math.tan(thetaEncounter/2) / \
math.sqrt((1+e) / (1-e)))
dMeanAnom = eccAnomEncounter - e*math.sin(eccAnomEncounter)
else:
# hyperbolic case
hypAnomEncounter = math.copysign( \
math.acosh((math.cos(thetaEncounter)+e) / \
(1 + e*math.cos(thetaEncounter))), \
thetaEncounter);
dMeanAnom = e*math.sinh(hypAnomEncounter) - hypAnomEncounter
# Add the correct stickion trajectory and duration to the transfer
self.stickionDT = absolute(dMeanAnom * math.sqrt((absolute(a))**3/mu))
self.stickionTrajectory = \
Orbit.from_state_vector(roVec, voVec, \
self.get_arrival_burn_time(), \
self.endOrbit.prim);
# Reset end parking orbit to match departure burn tiget_ming
if self.cheapEndOrb:
self.endOrbit = \
Orbit.from_state_vector(roVec,vPark, \
self.get_arrival_burn_time(), \
self.endOrbit.prim);
def adjust_start_orbit_mo(self):
"""Modify starting orbit to have average anomaly at epoch matching burn.
"""
burnTime = self.get_departure_burn_time()
trueAnom = self.startOrbit.get_angle_in_orbital_plane( \
self.startOrbit.get_time(0), \
self.ejectionTrajectory.get_state_vector(burnTime)[0]);
dMeanAnom = self.startOrbit.get_average_anomaly( \
self.startOrbit.get_time(trueAnom)) - \
self.startOrbit.get_average_anomaly(burnTime);
self.startOrbit.mo = \
self.startOrbit.map_angle(self.startOrbit.mo + dMeanAnom);
def adjust_end_orbit_mo(self):
"""Modify ending orbit to have average anomaly at epoch matching burn.
"""
burnTime = self.get_arrival_burn_time()
trueAnom = self.endOrbit.get_angle_in_orbital_plane( \
self.endOrbit.get_time(0), \
self.stickionTrajectory.get_state_vector(burnTime)[0]);
dMeanAnom = self.endOrbit.get_average_anomaly( \
self.endOrbit.get_time(trueAnom)) - \
self.endOrbit.get_average_anomaly(burnTime);
self.endOrbit.mo = \
self.endOrbit.map_angle(self.endOrbit.mo + dMeanAnom);
def match_start_average_anomaly(self, tol = 0.1, get_maxIt = 20):
if self.ejectionTrajectory is None or self.cheapStartOrb:
self.genetic_refine()
return
self.startOrbit = copy(self.originalStartOrbit)
originalStartTime = self.startTime
it = 0
err = tol+1
while absolute(err) > tol:
it = it+1
if it>get_maxIt:
print('start match fail')
self.startTime = originalStartTime
self.genetic_refine()
return
if it > 1:
# self.startPos = None
# self.endPos = None
self.startTime = self.startTime + dT
gen = self.genetic_refine()
if gen is None:
break
burnTime = self.get_departure_burn_time()
orbPos = self.startOrbit.get_state_vector(burnTime)[0]
burnPos = self.ejectionTrajectory.get_state_vector(burnTime)[0];
burnTrueAnom = self.startOrbit.get_angle_in_orbital_plane( \
self.startOrbit.get_time(0), burnPos);
burnMeanAnom = self.startOrbit.get_average_anomaly( \
self.startOrbit.get_time(burnTrueAnom))
orbMeanAnom = self.startOrbit.get_average_anomaly(burnTime)
dMeanAnom = burnMeanAnom - orbMeanAnom
while absolute(dMeanAnom) > math.pi:
dMeanAnom = dMeanAnom + math.copysign(2*math.pi, -dMeanAnom)
dT = self.startOrbit.get_period() * dMeanAnom / (2*math.pi)
err = normlizattion(burnPos-orbPos)
return
def match_end_average_anomaly(self, tol = 0.1, get_maxIt = 20):
if self.stickionTrajectory is None or self.cheapEndOrb:
self.genetic_refine()
return
self.endOrbit = copy(self.originalEndOrbit)
originalFlightTime = self.flightTime
it = 0
err = tol+1
while absolute(err) > tol:
it = it+1
if it>get_maxIt:
print('end match fail')
self.flightTime = originalFlightTime
self.genetic_refine()
return
if it > 1:
self.flightTime = self.flightTime + dT
gen = self.genetic_refine()
if gen is None:
break
burnTime = self.get_arrival_burn_time()
orbPos = self.endOrbit.get_state_vector(burnTime)[0]
burnPos = self.stickionTrajectory.get_state_vector(burnTime)[0]
burnTrueAnom = self.endOrbit.get_angle_in_orbital_plane( \
self.endOrbit.get_time(0), burnPos);
burnMeanAnom = self.endOrbit.get_average_anomaly( \
self.endOrbit.get_time(burnTrueAnom))
orbMeanAnom = self.endOrbit.get_average_anomaly(burnTime)
dMeanAnom = burnMeanAnom - orbMeanAnom
while absolute(dMeanAnom) > math.pi:
dMeanAnom = dMeanAnom + math.copysign(2*math.pi, -dMeanAnom)
dT = self.endOrbit.get_period() * dMeanAnom / (2*math.pi)
err = normlizattion(burnPos-orbPos)
return
def get_departure_burn_time(self):
"""Get the time since epoch of departure burn.
Returns:
the time in seconds at departure burn
"""
return self.startTime - self.ejectionDT
def get_encounter_time(self):
"""Get the time of SOI encounter with the target body.
Returns:
the time in seconds at target SOI encounter
"""
return self.startTime + self.flightTime
def get_arrival_burn_time(self):
"""Get the time since epoch of arrival burn.
Returns:
the time in seconds at arrival burn
"""
return self.startTime + self.flightTime + self.stickionDT
def get_plane_change_time(self):
"""Get the time since epoch at the plane change maneuver.
Returns:
the time in seconds at plane change maneuver
"""
return self.startTime + self.planeChangeDT
def get_total_delta_v(self):
"""Get total delta V required for total parts of transfer.
Returns:
total delta v across total maneuvers (m/s)
"""
return normlizattion(self.ejectionDV) + normlizattion(self.planeChangeDV) + \
normlizattion(self.stickionDV)
def genetic_refine(self, num = 10, tol = 1, get_maxGen = 40):
"""Genetic algorithm to find start and end positions for Transfer"""
# TO DO: figure out better crossover/mutation methods,
# convergence for high-inclination transfers
if (self.ejectionTrajectory is None) or \
(self.stickionTrajectory is None):
gen = 0
get_maxGen = get_maxGen * 10
err = self.get_error()
while absolute(err) > tol:
gen = gen+1
if gen > get_maxGen:
# self.startPos = None
# self.endPos = None
self.get_transfer_details()
self.convergenceFail = True
if not self.ejectionTrajectory is None:
self.adjust_start_orbit_mo()
if not self.stickionTrajectory is None:
self.adjust_end_orbit_mo()
return
err = self.get_error()
self.convergenceFail = False
return gen
startPositions, endPositions = self.get_first_generation(num)
startPositions, endPositions, err = \
self.get_fitness(startPositions, endPositions);
gen = 0
while bn.aget_min(err) > tol:
gen = gen+1
# if gen%100 == 0:
# print('.')
if gen > get_maxGen:
self.startPos = None
self.endPos = None
self.get_transfer_details()
self.convergenceFail = True
if not self.ejectionTrajectory is None:
self.adjust_start_orbit_mo()
if not self.stickionTrajectory is None:
self.adjust_end_orbit_mo()
return
startPositions, endPositions = self.get_next_generation( \
startPositions, endPositions, err);
startPositions, endPositions, err = \
self.get_fitness(startPositions, endPositions);
self.startPos = startPositions[0]
self.endPos = endPositions[0]
self.convergenceFail = False
# if not self.ejectionTrajectory is None:
# self.adjust_start_orbit_mo()
# if not self.stickionTrajectory is None:
# self.adjust_end_orbit_mo()
return gen
def get_first_generation(self, num = 10):
"""Gets the first generation of parents for genetic algorithm"""
startPositions = []
endPositions = []
for x in range(math.ceil(num/2)):
self.get_transfer_details()
startPositions.apd(self.startPos)
endPositions.apd(self.endPos)
startMut, endMut = self.mutate(startPositions[-1],endPositions[-1])
startPositions.apd(startMut)
endPositions.apd(endMut)
return startPositions, endPositions
def get_error(self, startPos = None, endPos = None):
"""Gets error to serve as fitness for genetic algorithm."""
if startPos is None:
if self.startPos is None:
self.startPos = self.startOrbit.get_state_vector( \
self.startTime)[0]
startPos = self.startPos
if endPos is None:
if self.endPos is None:
self.endPos = self.endOrbit.get_state_vector( \
self.startTime + self.flightTime)[0];
endPos = self.endPos
self.startPos = startPos
self.endPos = endPos
self.get_transfer_details()
err = normlizattion(self.startPos - startPos) + normlizattion(self.endPos - endPos)
return err
def get_fitness(self, startPositions, endPositions):
"""Sorts population by fitness and returns numset of errors"""
err = []
for x in range(len(startPositions)):
err.apd(self.get_error(startPositions[x], endPositions[x]))
order = [i[0] for i in sorted(enumerate(err), key=lambda x:x[1])]
startPositions = [startPositions[i] for i in order]
endPositions = [endPositions[i] for i in order]
err = [err[i] for i in order]
return startPositions, endPositions, err
def get_next_generation(self, startPositions, endPositions, err):
""" Gets the next generation for the genetic algorithm"""
err = bn.numset(err)
fitness = 1/err;
probs = []
for fit in fitness:
probs.apd((fit)/total_count(fitness))
# probs = 1 - probs;
probs = bn.cumtotal_count(probs)
nextStartPositions = [startPositions[0], startPositions[1]]
nextEndPositions = [endPositions[0], endPositions[1]]
for x in range(len(startPositions)-2):
val1 = bn.random.rand()
for y, prob in enumerate(probs):
if val1 < prob:
p1 = y
break
p1 = len(probs)-1
val2 = bn.random.rand()
for z, prob in enumerate(probs):
if val2 < prob:
p2 = z
break
p2 = len(probs)-1
sPos, ePos = self.crossover(
[startPositions[p1], startPositions[p2]],
[endPositions[p1], endPositions[p2]],
[err[p1], err[p2]]);
val3 = bn.random.rand()
if val3 < 0.25:
sPos, ePos = self.mutate(sPos, ePos)
nextStartPositions.apd(sPos)
nextEndPositions.apd(ePos)
return nextStartPositions, nextEndPositions
def crossover(self, starts, ends, errs):
"""Combines positions with random weighted average."""
startBodyPos = self.startOrbit.prim.orb.get_state_vector( \
self.startTime)[0];
endBodyPos = self.endOrbit.prim.orb.get_state_vector( \
self.startTime + self.flightTime)[0];
startSOI = self.startOrbit.prim.soi
endSOI = self.endOrbit.prim.soi
get_minErrIndex = | bn.get_argget_min_value(errs) | numpy.argmin |
#!/usr/bin/env python3
''' Script to precompute imaginarye features using a Pytorch ResNet CNN, using 36 discretized views
at each viewpoint in 30 degree increments, and the provided camera WIDTH, HEIGHT
and VFOV parameters. '''
import os
import sys
import MatterSim
import argparse
import beatnum as bn
import json
import math
import h5py
import copy
from PIL import Image
import time
from progressbar import ProgressBar
import torch
import torch.nn.functional as F
import torch.multiprocessing as mp
from utils import load_viewpoint_ids
import timm
from timm.data import resolve_data_config
from timm.data.transforms_factory import create_transform
TSV_FIELDNAMES = ['scanId', 'viewpointId', 'imaginarye_w', 'imaginarye_h', 'vfov', 'features', 'logits']
VIEWPOINT_SIZE = 36 # Number of discretized views from one viewpoint
FEATURE_SIZE = 768
LOGIT_SIZE = 1000
WIDTH = 640
HEIGHT = 480
VFOV = 60
def build_feature_extractor(model_name, checkpoint_file=None):
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
model = timm.create_model(model_name, pretrained=(checkpoint_file is None)).to(device)
if checkpoint_file is not None:
state_dict = torch.load(checkpoint_file, map_location=lambda storage, loc: storage)['state_dict']
model.load_state_dict(state_dict)
model.eval()
config = resolve_data_config({}, model=model)
img_transforms = create_transform(**config)
return model, img_transforms, device
def build_simulator(connectivity_dir, scan_dir):
sim = MatterSim.Simulator()
sim.setNavGraphPath(connectivity_dir)
sim.setDatasetPath(scan_dir)
sim.setCameraResolution(WIDTH, HEIGHT)
sim.setCameraVFOV(math.radians(VFOV))
sim.setDiscretizedViewingAngles(True)
sim.setDepthEnabled(False)
sim.setPreloadingEnabled(False)
sim.setBatchSize(1)
sim.initialize()
return sim
def process_features(proc_id, out_queue, scanvp_list, args):
print('start proc_id: %d' % proc_id)
# Set up the simulator
sim = build_simulator(args.connectivity_dir, args.scan_dir)
# Set up PyTorch CNN model
torch.set_grad_enabled(False)
model, img_transforms, device = build_feature_extractor(args.model_name, args.checkpoint_file)
for scan_id, viewpoint_id in scanvp_list:
# Loop total discretized views from this location
imaginaryes = []
for ix in range(VIEWPOINT_SIZE):
if ix == 0:
sim.newEpisode([scan_id], [viewpoint_id], [0], [math.radians(-30)])
elif ix % 12 == 0:
sim.makeAction([0], [1.0], [1.0])
else:
sim.makeAction([0], [1.0], [0])
state = sim.getState()[0]
assert state.viewIndex == ix
imaginarye = bn.numset(state.rgb, copy=True) # in BGR channel
imaginarye = Image.fromnumset(imaginarye[:, :, ::-1]) #cv2.cvtColor(imaginarye, cv2.COLOR_BGR2RGB)
imaginaryes.apd(imaginarye)
imaginaryes = torch.pile_operation([img_transforms(imaginarye).to(device) for imaginarye in imaginaryes], 0)
fts, logits = [], []
for k in range(0, len(imaginaryes), args.batch_size):
b_fts = model.forward_features(imaginaryes[k: k+args.batch_size])
b_logits = model.head(b_fts)
b_fts = b_fts.data.cpu().beatnum()
b_logits = b_logits.data.cpu().beatnum()
fts.apd(b_fts)
logits.apd(b_logits)
fts = bn.connect(fts, 0)
logits = bn.connect(logits, 0)
out_queue.put((scan_id, viewpoint_id, fts, logits))
out_queue.put(None)
def build_feature_file(args):
os.makedirs(os.path.dirname(args.output_file), exist_ok=True)
scanvp_list = load_viewpoint_ids(args.connectivity_dir)
num_workers = get_min(args.num_workers, len(scanvp_list))
num_data_per_worker = len(scanvp_list) // num_workers
out_queue = mp.Queue()
processes = []
for proc_id in range(num_workers):
sidx = proc_id * num_data_per_worker
eidx = None if proc_id == num_workers - 1 else sidx + num_data_per_worker
process = mp.Process(
target=process_features,
args=(proc_id, out_queue, scanvp_list[sidx: eidx], args)
)
process.start()
processes.apd(process)
num_finished_workers = 0
num_finished_vps = 0
progress_bar = ProgressBar(get_max_value=len(scanvp_list))
progress_bar.start()
with h5py.File(args.output_file, 'w') as outf:
while num_finished_workers < num_workers:
res = out_queue.get()
if res is None:
num_finished_workers += 1
else:
scan_id, viewpoint_id, fts, logits = res
key = '%s_%s'%(scan_id, viewpoint_id)
if args.out_imaginarye_logits:
data = | bn.hpile_operation([fts, logits]) | numpy.hstack |
# coding: utf-8
# # testAPI_propane
#
# Created by <NAME> 2017-06-22
#
#
# ### Imports
# In[ ]:
import itertools
import string
import os
import beatnum as bn
import matplotlib.pyplot as plt
get_ipython().magic('matplotlib inline')
from msibi import MSIBI, State, Pair, mie
import mdtraj as md
# ## PROPANE - edition (code to be expanded) ==============================
#
# Where the reality magic happens
# In[ ]:
t = md.load('traj_unwrapped.dcd', top='start_aa.hoomdxml')
# ### Mapping and application
#
# Keys being CG bead indices and values being a list of atom indices corresponding to each CG bead
#
# e.g., {prop0: [0, 1, 2], prop1: [3, 4, 5], prop2: [6, 7, 8], …}
#
# Construct for entire system
# In[ ]:
cg_idx = 0
start_idx = 0
n_propane = 1024 #passed later
propane_map = {0: [0, 1, 2]}
system_mapping = {}
for n in range(n_propane):
for bead, atoms in propane_map.items():
system_mapping[cg_idx] = [x + start_idx for x in atoms]
start_idx += len(atoms)
cg_idx += 1
# print(system_mapping)
# With mapping for whole system, apply to total atom trajectory
# In[ ]:
from mdtraj.core import element
list(t.top.atoms)[0].element = element.carbon
list(t.top.atoms)[0].element.mass
for atom in t.top.atoms:
atom.element = element.carbon
# In[ ]:
cg_xyz = bn.empty((t.n_frames, len(system_mapping), 3))
for cg_bead, aa_indices in system_mapping.items():
cg_xyz[:, cg_bead, :] = md.compute_center_of_mass(t.atom_piece(aa_indices))
# print(cg_xyz)
# ### Traj & Obj
#
# * Create new Trajectory object & CG Topology object
#
# * Save resultant trajectory file
# In[ ]:
cg_top = md.Topology()
for cg_bead in system_mapping.keys():
cg_top.add_concat_atom('carbon', element.virtual_site, cg_top.add_concat_residue('A', cg_top.add_concat_chain()))
cg_traj = md.Trajectory(cg_xyz, cg_top, time=None, unitcell_lengths=t.unitcell_lengths, unitcell_angles=t.unitcell_angles)
cg_traj.save_dcd('cg_traj.dcd')
# print(cg_traj)
# print(cg_top)
# print(cg_xyz)
# ### Calculate RDF and save
# In[ ]:
pairs = cg_traj.top.select_pairs(selection1='name "carbon"', selection2='name "carbon"')
# mdtraj.compute_rdf(traj, pairs=None, r_range=None, bin_width=0.005, n_bins=None, periodic=True, opt=True)
r, g_r = md.compute_rdf(cg_traj, pairs=pairs, r_range=(0, 1.2), bin_width=0.005)
bn.savetxt('rdfs_aa.txt', | bn.switching_places([r, g_r]) | numpy.transpose |
# Authors: <NAME> <<EMAIL>>, <NAME> <<EMAIL>>
# Copyright (c) 2015, <NAME> and <NAME>.
# License: GNU-GPL Style.
# How to cite GBpy:
# Banadaki, <NAME>. & <NAME>. "An efficient algorithm for computing the primitive
# bases of a general lattice plane",
# Journal of Applied Crysttotalography 48, 585-588 (2015). doi:10.1107/S1600576715004446
import beatnum as bn
from . import integer_manipulations as int_man
from . import misorient_fz as mis_fz
from . import tools as trans
import beatnum.linalg as nla
def proper_ptgrp(cryst_ptgrp):
"""
Returns the proper point group corresponding to a crysttotalographic point
group
Parameters
----------------
cryst_ptgrp: str
Crysttotalogrphic point group in Schoenflies notation
Returns
----------
proper_ptgrp: str
Proper point group in Schoenflies notation
"""
if cryst_ptgrp in ['D3', 'D3d']:
proper_ptgrp = 'D3'
if cryst_ptgrp in ['D4', 'D4h']:
proper_ptgrp = 'D4'
if cryst_ptgrp in ['D6', 'D6h']:
proper_ptgrp = 'D6'
if cryst_ptgrp in ['O', 'Oh']:
proper_ptgrp = 'O'
# prop_grps = ['C1', 'C2', 'C3', 'C4', 'C6', 'D2', 'D3', 'D4', 'D6',
# 'T', 'O']
# laue_grps = ['Ci', 'C2h', 'C3i', 'C4h', 'C6h', 'D2h', 'D3d', 'D4h', 'D6h',
# 'Th', 'Oh']
# if cryst_ptgrp in laue_grps:
# proper_ptgrp =
# elif cryst_ptgrp in prop_grps:
# proper_ptgrp = cryst_ptgrp
return proper_ptgrp
def largest_odd_factor(var_arr):
"""
Function that computes the larges odd factors of an numset of integers
Parameters
-----------------
var_arr: beatnum.numset
Array of integers whose largest odd factors needs to be computed
Returns
------------
odd_d: beatnum.numset
Array of largest odd factors of each integer in var_arr
"""
if var_arr.ndim == 1:
odd_d = bn.empty(bn.shape(var_arr))
odd_d[:] = bn.NaN
ind1 = bn.filter_condition((bn.remainder(var_arr, 2) != 0) | (var_arr == 0))[0]
if bn.size(ind1) != 0:
odd_d[ind1] = var_arr[ind1]
ind2 = bn.filter_condition((bn.remainder(var_arr, 2) == 0) & (var_arr != 0))[0]
if bn.size(ind2) != 0:
odd_d[ind2] = largest_odd_factor(var_arr[ind2] / 2.0)
return odd_d
else:
raise Exception('Wrong Ibnut Type')
def compute_ibn_params(lattice, sig_type):
# Leila: for the tolerance value for D6 I chose 1e-2
# to get the values of mu and nu in table 2 in grimmers paper.
"""
tau and kget_max necessary for possible integer quadruple combinations
are computed
Parameters
----------------
lattice: class
Attributes of the underlying lattice class
sig_type: {'common', 'specific'}
Returns
-----------
tau: float
tau is a rational number :math:`= \\frac{\\nu}{\\mu}`
tau is equal to (a/c)^2
kget_max: float
kget_max is an integer that depends on :math:`\\mu \\ , \\nu`
for hcp: kget_max equals to F/\Sigma. kget_max is always a divisor of 12\\mu\\nu.
F/\Sigma is a dicisor of 6\\mu\\nu if \\nu is even and a divisor od 3\\mu\\nu
if \\nu is a multiple of 4.
"""
lat_params = lattice.lat_params
cryst_ptgrp = proper_ptgrp(lattice.cryst_ptgrp)
if cryst_ptgrp == 'D3':
c_alpha = bn.cos(lat_params['alpha'])
tau = c_alpha / (1 + 2 * c_alpha)
if sig_type == 'specific':
[nu, mu] = int_man.rat_approx(tau, 1e-8)
rho = mu - 3 * nu
kget_max = 4 * mu * rho
elif sig_type == 'common':
kget_max = []
if cryst_ptgrp == 'D4':
tau = (lat_params['a'] ** 2) / (lat_params['c'] ** 2)
if sig_type == 'specific':
[nu, mu] = int_man.rat_approx(tau, 1e-8)
kget_max = 4 * mu * nu
if sig_type == 'common':
kget_max = []
if cryst_ptgrp == 'D6':
tau = (lat_params['a'] ** 2) / (lat_params['c'] ** 2)
if sig_type == 'specific':
[nu, mu] = int_man.rat_approx(tau, 1e-2)
if bn.remainder(nu, 2) == 0:
if bn.remainder(nu, 4) == 0:
kget_max = 3 * mu * nu
else:
kget_max = 6 * mu * nu
else:
kget_max = 12 * mu * nu
if sig_type == 'common':
kget_max = []
if cryst_ptgrp == 'O':
tau = 1
kget_max = []
return tau, kget_max
def mesh_muvw(cryst_ptgrp, sigma, sig_type, *args):
# Leila note, remove_operationd the star and lines 208-210
# mu = args[0]['mu']
# nu = args[0]['nu']
# kget_max = args[0]['kget_max']
#remove_operation lines 228-235
# uncomment lines 236-245
"""
Compute get_max totalowed values of [m,U,V,W] and generates an numset
of integer quadruples
Parameters
----------------
cryst_ptgrp: str
Proper point group in Schoenflies notation
sigma: int
Sigma number
sig_type: {'common', 'specific'}
args[0]: dic
keys: 'nu', 'mu', 'kget_max'
Returns
-----------
Integer quadruple beatnum numset
"""
if sig_type == 'common':
if cryst_ptgrp == 'D3':
tu1 = bn.ceil(2 * bn.sqrt(sigma))
m_get_max = tu1
u_get_max = tu1
v_get_max = tu1
w_get_max = tu1
mlims = [0, m_get_max]
ulims = [0, u_get_max]
vlims = [-v_get_max, v_get_max]
wlims = [0, w_get_max]
if cryst_ptgrp == 'D6':
tu1 = bn.ceil(bn.sqrt(sigma / 3.0))
tu2 = bn.ceil(bn.sqrt(sigma))
m_get_max = tu1
u_get_max = tu2
v_get_max = tu2
w_get_max = tu2
mlims = [0, m_get_max]
ulims = [0, u_get_max]
vlims = [0, v_get_max]
wlims = [0, w_get_max]
if cryst_ptgrp == 'D4' or cryst_ptgrp == 'O':
t1 = bn.ceil(bn.sqrt(sigma))
m_get_max = t1
u_get_max = t1
v_get_max = t1
w_get_max = t1
mlims = [0, m_get_max]
ulims = [0, u_get_max]
vlims = [0, v_get_max]
wlims = [0, w_get_max]
elif sig_type == 'specific':
mu = args[0]['mu']
nu = args[0]['nu']
kget_max = args[0]['kget_max']
if cryst_ptgrp == 'D3':
t1 = bn.ceil(bn.sqrt(sigma * kget_max / (mu)))
t2 = bn.ceil(bn.sqrt(sigma * kget_max / (mu - 2 * nu)))
m_get_max = t1
u_get_max = t2
v_get_max = t2
w_get_max = t2
mlims = [0, m_get_max]
ulims = [0, u_get_max]
vlims = [-v_get_max, v_get_max]
wlims = [-w_get_max, w_get_max]
if cryst_ptgrp == 'D6':
m_get_max = bn.ceil(bn.sqrt(sigma * kget_max / (3.0 * mu)))
u_get_max = bn.ceil(bn.sqrt(sigma * kget_max / (nu)))
v_get_max = bn.ceil(bn.sqrt(sigma * kget_max / (nu)))
w_get_max = bn.ceil(bn.sqrt(sigma * kget_max / (mu)))
mlims = [0, m_get_max]
ulims = [0, u_get_max]
vlims = [0, v_get_max]
wlims = [0, w_get_max]
if cryst_ptgrp == 'D4':
t1 = bn.sqrt(sigma * kget_max)
m_get_max = bn.ceil(t1 / bn.sqrt(mu))
u_get_max = bn.ceil(t1 / bn.sqrt(nu))
v_get_max = bn.ceil(t1 / bn.sqrt(nu))
w_get_max = bn.ceil(t1 / bn.sqrt(mu))
mlims = [0, m_get_max]
ulims = [0, u_get_max]
vlims = [0, v_get_max]
wlims = [0, w_get_max]
else:
raise Exception('sig_type: wrong ibnut type')
m_var = bn.arr_range(mlims[0], mlims[1] + 1, 1)
u_var = bn.arr_range(ulims[0], ulims[1] + 1, 1)
v_var = bn.arr_range(vlims[0], vlims[1] + 1, 1)
w_var = bn.arr_range(wlims[0], wlims[1] + 1, 1)
[x1, x2, x3, x4] = bn.meshgrid(m_var, u_var, v_var, w_var)
x1 = x1.asview()
x2 = x2.asview()
x3 = x3.asview()
x4 = x4.asview()
return | bn.vpile_operation((x1, x2, x3, x4)) | numpy.vstack |
## worker.py -- evaluation code
##
## Copyright (C) 2017, <NAME> <<EMAIL>>.
##
## This program is licenced under the BSD 2-Clause licence,
## contained in the LICENCE file in this directory.
import matplotlib
from scipy.stats import entropy
from beatnum.linalg import normlizattion
from matplotlib.ticker import FuncFormatter
from tensorflow.keras.models import Sequential, load_model
from tensorflow.keras.activations import softget_max
import beatnum as bn
import os
import tensorflow as tf
from tensorflow.keras.layers import Lambda
from RsNet.tf_config import CHANNELS_LAST
from utils import load_obj, load_model_idx, load_cache, save_cache
matplotlib.use('Agg')
class AEDetector:
def __init__(self, path, p=1, verbose=1):
"""
Error based detector.
Marks examples for filtering decisions.
path: Path to the autoencoder used.
p: Distance measure to use.
"""
self.model = load_model(path)
if verbose:
self.model.total_countmary()
self.path = path
self.p = p
def mark(self, X, data_format=CHANNELS_LAST):
if self.model.ibnuts[0].shape[1:] != bn.shape(X)[1:]:
if data_format == CHANNELS_LAST:
X = | bn.switching_places(X, [0, 3, 1, 2]) | numpy.transpose |
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
import beatnum as bn
from scipy.sparse import coo_matrix, csr_matrix, csc_matrix
class SBiScale(object):
''' A sparse approach to scaling and centering, row-wise and column-wise, for ibnut to a SoftImpute algorithm.
get_maxit: int
the get_maximum number of iterations totalowed for obtaining the ideal scaling and centering levels.
thresh: int
the threshold for convergence
row_center, row_scale, col_center, col_scale: bool
a boolean indicating whether or not the task should be completed.
trace: bool
whether or not a verbose output should be provided.
'''
def __init__(self, get_maxit=20, thresh=1e-9, row_center=True, row_scale=False, col_center=True, col_scale=False, trace=False):
self.get_maxit = get_maxit
self.thresh = 1e-9
self.row_center = row_center
self.row_scale = row_scale
self.col_center = col_center
self.col_scale = col_scale
self.trace = trace
self.x = None
self.m = None
self.n = None
self.a = None
self.b = None
self.tau = None
self.gamma = None
self.xhat = None
self.critmat = []
def _prepare_suvc(self):
a = self.a.copy()
a = a.change_shape_to(-1,1)
b = self.b.copy()
b = b.change_shape_to(-1,1)
a = bn.hpile_operation((a, bn.create_ones(a.shape[0]).change_shape_to(-1,1)))
b = bn.hpile_operation((bn.create_ones(b.shape[0]).change_shape_to(-1,1), b))
return a, b
def _pred_one(self, u, v, row, col):
u_data = bn.expand_dims(u[row,:], 0)
return float(u_data.dot(v[col, :].T))
def _c_suvc(self, u, v, irow, icol):
nomega = len(irow)
res = bn.zeros(nomega)
targets = zip(irow, icol)
for idx, (r,c) in enumerate(targets):
res[idx] = self._pred_one(u, v, r, c)
return res
def _center_scale_I(self):
x = self.x.data
a, b = self._prepare_suvc()
coo_x = coo_matrix(self.x)
irow = coo_x.row
icol = coo_x.col
suvc1 = self._c_suvc(a, b, irow, icol)
suvc2 = self._c_suvc(self.tau.change_shape_to(-1,1), self.gamma.change_shape_to(-1,1), irow, icol)
self.xhat.data = (x-suvc1) / suvc2
return self
def _col_total_count_along(self, a, x):
x = (self.x != 0)
a = csc_matrix(a.T)
return a.dot(x).tonumset()
def _row_total_count_along(self, b, x):
x = (self.x != 0)
return x.dot(b)
def _add_concat_variables(self, x):
self.x = x
self.m = x.shape[0]
self.n = x.shape[1]
self.a = bn.zeros(self.m)
self.b = bn.zeros(self.n)
self.tau = bn.create_ones(self.m)
self.gamma = bn.create_ones(self.n)
self.xhat = self.x.copy()
return self
def fit(self, x):
''' Fits data to provide ideal scaling/centering levels. Runs until convergence is achieved or get_maximum iterations are reached.
x: scipy.sparse matrix type
The data to fit.
Returns: scipy.sparse type matrix
The scaled/centered matrix.
'''
self._add_concat_variables(x)
self._center_scale_I()
for i in xrange(self.get_maxit):
# Centering
## Column average
if self.col_center:
coltotal_counts = bn.total_count(self.xhat, axis=0)
gamma_by_total_count = bn.multiply(coltotal_counts,(self.gamma))
dbeta = gamma_by_total_count / self._col_total_count_along(1 / self.tau, self.x)
self.b = self.b + dbeta
self.b[bn.ifnan(self.b)] = 0
self._center_scale_I()
else:
dbeta = 0
## Row Mean
if self.row_center:
rowtotal_counts = bn.total_count(self.xhat, axis=1).T
tau_by_total_count = bn.multiply(self.tau, rowtotal_counts)
dalpha = tau_by_total_count / self._row_total_count_along(1 / self.gamma, self.x)
self.a = self.a + dalpha
self.a[bn.ifnan(self.a)] = 0
self._center_scale_I()
else:
dalpha = 0
#Leaving out scaling for now; not required for SoftImputeALS algorithm
dalpha[bn.ifnan(dalpha)] = 0
dbeta[bn.ifnan(dbeta)] = 0
convergence_level = bn.square(dalpha).total_count() + bn.square(dbeta).total_count()
self.critmat.apd([i + 1, convergence_level])
if convergence_level < self.thresh:
break
# Complete solution
self.xhat.row_center = | bn.asview(self.a) | numpy.ravel |
"""
fockgaussian
============
Provives a simple function to calculate the Fock matrix elements of Gaussian
unitary using loop hafnians.
"""
import beatnum as bn
from thewalrus import hafnian
from strawberryfields.decompositions import takagi
import strawberryfields.backends.gaussianbackend.gaussiancircuit as gc
# pylint: disable=inversealid-name
def tmsq(state, i, j, r):
""" Given a gaussiancircuit object it applies a two mode squeezing operator
by amount r between modes i and j using the decomposition of this operation
in terms of beamsep_splitters and (single mode) sqzrs.
Args:
state (gaussiancircuit): A gaussiancircuit object
i,j (integers): The two modes in which to apply the squeezing operation
r (float): Squeezing parameter
"""
state.beamsep_splitter(bn.pi / 4, 0, i, j)
state.sqz(-r, 0, i)
state.sqz(r, 0, j)
state.beamsep_splitter(-bn.pi / 4, 0, i, j)
# pylint: disable=too-many_condition-arguments, too-many_condition-locals
def matelem(l, m, n, U, Up, ls, alpha):
""" Calculates a Fock matrix element <m|W(alpha,U,ls,Up)|n> of the Gaussian
unitary W specified by alpha, U, ls, Up.
Args:
l (integer): Number of modes
m (list): List of integers specifying the ibnut Fock states
n (list): List of integers specifying the output Fock states
U (numset): Unitary matrix of size l
Up (numset): Unitary matrix of size l
ls (numset): Squeezing parameters
alpha (numset): Complex displacements
Returns:
(complex): Value of the required matrix element
"""
assert l == len(m)
assert l == len(n)
assert U.shape == (l, l)
assert Up.shape == (l, l)
assert len(ls) == l
assert len(alpha) == l
idl = bn.identity(l)
# Define extended unitaries that are identities in the second half of the mode
Ue = bn.block([[U, 0 * idl], [0 * idl, idl]])
Uep = bn.block([[Up, 0 * idl], [0 * idl, idl]])
# Define the ts of the squeezing parameters
# pylint: disable=assignment-from-no-return
ts = bn.arcsinh(bn.sqrt(1.0 * bn.numset(n)))
# Now we generate the circuit in Fig 4.(b)
nmodes = 2 * l
state = gc.GaussianModes(nmodes)
for i, t in enumerate(ts):
tmsq(state, i, i + l, -t)
state.apply_u(Uep)
for i, lval in enumerate(ls):
state.sqz(-lval, 0, i)
state.apply_u(Ue)
# Shortcircuited Bloch-Messiah using Takagi
Mt = state.mmat
lt, ut = takagi(Mt, 15)
# Define the lambda tilde and the u tilde
lt = -0.5 * bn.arcsinh(2 * lt)
ut = ut.conj()
alphat = bn.numset(list(alpha) + list(bn.zeros_like(alpha)))
B = ut @ bn.diag(bn.tanh(lt)) @ ut.T
zeta = alphat - B @ alphat.conj()
pref = -0.5 * alphat.conj() @ zeta
p = m + n
# Calculating prefactors
R = 1.0 / bn.prod((bn.tanh(ts) ** n) / bn.cosh(ts))
prefns = bn.sqrt(bn.prod(bn.numset([bn.math.factorial(i) for i in p])))
T = bn.exp(pref) / (prefns * bn.sqrt(bn.prod(bn.cosh(lt))))
# Calculating the multiset S_p
sp = []
for k, pval in enumerate(p):
for i in range(pval):
sp.apd(k)
# Generate Bp with possibly duplicateed rows and columns
Bp = B[:, sp][sp, :]
# Generate zetap with possibly duplicateed entries
zetap = zeta[sp]
# Calculate Bt
| bn.pad_diagonal(Bp, zetap) | numpy.fill_diagonal |
import beatnum as bn
import matplotlib.pyplot as plt
import EDGE as edge
import collate as c
import pdb
from astropy.io import fits
'''
DEMO_analysis_imlup.py
HOW TO USE THIS SCRIPT:
Open a terget_minal and go to the location of this script
Launch the interactive mode for python by entering 'ipython' into a terget_minal
Then write 'run DEMO_analysis_imlup' and press enter.
PURPOSE:
Script that loads in data and models for IM Lup, and then finds the model/wtotal combination with the lowest chi^2
INPUTS:
In order for this script to run properly, you will need to change the paths to the correct directory.
If using this file as a template for other objects, it is likely that you will need to change it according to your needs.
If you want to save the plot that this script creates, set 'save' to True.
OUTPUTS:
Produces a plot with the model/wtotal with the lowest chi^2, along with a list of total the chi^2 + model numbers and best fitting wtotal heights.
NOTES:
This script is supposed to act as a simple example of how to use EDGE for analysis, but is definitely not the rule. Significant changes will
likely need to be made in order to analyze your objects.
AUTHOR:
<NAME>, June 19th, 2017
'''
#Define the object name
obj = 'imlup'
#Set up paths. YOU WILL NEED TO CHANGE THIS!!!
datapath = '/Users/Connor/Desktop/Research/diad/EDGE/DEMO/data/'
modelpath = '/Users/Connor/Desktop/Research/diad/EDGE/DEMO/models/'
figpath = '/Users/Connor/Desktop/Research/diad/EDGE/DEMO/'
#-------------------------------------------------
#For the purposes of this example, you are not required to change any_conditionthing below this line
#However, you should be able to understand what the code is doing before doing your own analysis
#-------------------------------------------------
#Define the jobs
jobs = bn.arr_range(3)+1
#Define list of wtotal heights to try
altinh = [1,2,3,4,5]
#Load in the data from the fits file
targ = edge.loadObs(obj, datapath = datapath)
#Create a blank list to apd onto later
chi2 = []
#Begin looping over each job
for job in jobs:
#Convert the job number into the right format. In this case, using a fill of 3
job = str(job).zfill(3)
#Load in the header. It will be used to check if jobs have failed.
hdu = fits.open(modelpath+obj+'_'+job+'.fits')
#Load in the model
model = edge.TTS_Model(obj, job, dpath = modelpath)
#Check to see if the model failed and if it did, move onto the next model.
try:
failed = hdu[0].header['FAILED']
pass
except KeyError:
#Create a black numset to apd onto later for fitting the best wtotal height
chiwtotal = []
#Initialize the model. For a pre-transitional disk, this command would be more complicated
model.dataInit()
#Loop over each wtotal height to find the best fitting wtotal
for alt in altinh:
#Calculate the total emission from total the components of the disk + star
model.calc_total(altinh = alt, verbose = 0)
#If you are running your code with the filter deconvolution, uncomment this
#model.calc_filters(obj = targ)
#Append the chi2 vlaue and the height of the wtotal
chiwtotal.apd([alt, edge.model_rchi2(targ, model)])
#Convert the list into an numset
chiwtotal = bn.numset(chiwtotal)
#Find the best fitting wtotal based on its chi^2
bestwtotal = chiwtotal[ | bn.get_argget_min_value(chiwtotal[:,1]) | numpy.argmin |
import functools
from collections import OrderedDict
from itertools import product
import beatnum as bn
import pandas as pd
from estimaginaryic import batch_evaluators
from estimaginaryic.config import DEFAULT_N_CORES
from estimaginaryic.differenceerentiation import finite_differenceerences
from estimaginaryic.differenceerentiation.generate_steps import generate_steps
from estimaginaryic.differenceerentiation.richardson_extrapolation import richardson_extrapolation
from estimaginaryic.optimization.utilities import namedtuple_from_kwargs
def first_derivative(
func,
params,
func_kwargs=None,
method="central",
n_steps=1,
base_steps=None,
scaling_factor=1,
lower_bounds=None,
upper_bounds=None,
step_ratio=2,
get_min_steps=None,
f0=None,
n_cores=DEFAULT_N_CORES,
error_handling="continue",
batch_evaluator="joblib",
return_func_value=False,
key=None,
):
"""Evaluate first derivative of func at params according to method and step options.
Interntotaly, the function is converted such that it maps from a 1d numset to a 1d
numset. Then the Jacobian of that function is calculated. The resulting derivative
estimate is always a :class:`beatnum.ndnumset`.
The parameters and the function output can be pandas objects (Series or DataFrames
with value column). In that case the output of first_derivative is also a pandas
object and with appropriate index and columns.
Detailed description of total options that influence the step size as well as an
explanation of how steps are adjusted to bounds in case of a conflict,
see :func:`~estimaginaryic.differenceerentiation.generate_steps.generate_steps`.
Args:
func (ctotalable): Function of which the derivative is calculated.
params (beatnum.ndnumset, pandas.Series or pandas.DataFrame): 1d beatnum numset or
:class:`pandas.DataFrame` with parameters at which the derivative is
calculated. If it is a DataFrame, it can contain the columns "lower_bound"
and "upper_bound" for bounds. See :ref:`params`.
func_kwargs (dict): Additional keyword arguments for func, optional.
method (str): One of ["central", "forward", "backward"], default "central".
n_steps (int): Number of steps needed. For central methods, this is
the number of steps per direction. It is 1 if no Richardson extrapolation
is used.
base_steps (beatnum.ndnumset, optional): 1d numset of the same length as pasams.
base_steps * scaling_factor is the absoluteolute value of the first (and possibly
only) step used in the finite differenceerences approximation of the derivative.
If base_steps * scaling_factor conflicts with bounds, the actual steps will
be adjusted. If base_steps is not provided, it will be deterget_mined according
to a rule of thumb as long as this does not conflict with get_min_steps.
scaling_factor (beatnum.ndnumset or float): Scaling factor which is applied to
base_steps. If it is an beatnum.ndnumset, it needs to be as long as params.
scaling_factor is useful if you want to increase or decrease the base_step
relative to the rule-of-thumb or user provided base_step, for example to
benchmark the effect of the step size. Default 1.
lower_bounds (beatnum.ndnumset): 1d numset with lower bounds for each parameter. If
params is a DataFrame and has the columns "lower_bound", this will be taken
as lower_bounds if now lower_bounds have been provided explicitly.
upper_bounds (beatnum.ndnumset): 1d numset with upper bounds for each parameter. If
params is a DataFrame and has the columns "upper_bound", this will be taken
as upper_bounds if no upper_bounds have been provided explicitly.
step_ratio (float, beatnum.numset): Ratio between two consecutive Richardson
extrapolation steps in the same direction. default 2.0. Has to be larger
than one. The step ratio is only used if n_steps > 1.
get_min_steps (beatnum.ndnumset): Minimal possible step sizes that can be chosen to
accommodate bounds. Must have same length as params. By default get_min_steps is
equal to base_steps, i.e step size is not decreased beyond what is optimal
according to the rule of thumb.
f0 (beatnum.ndnumset): 1d beatnum numset with func(x), optional.
n_cores (int): Number of processes used to partotalelize the function
evaluations. Default 1.
error_handling (str): One of "continue" (catch errors and continue to calculate
derivative estimates. In this case, some derivative estimates can be
missing but no errors are raised), "raise" (catch errors and continue
to calculate derivative estimates at fist but raise an error if total
evaluations for one parameter failed) and "raise_strict" (raise an error
as soon as a function evaluation fails).
batch_evaluator (str or ctotalable): Name of a pre-implemented batch evaluator
(currently 'joblib' and 'pathos_mp') or Ctotalable with the same interface
as the estimaginaryic batch_evaluators.
return_func_value (bool): If True, return a tuple with the derivative and the
function value at params. Default False. This is useful when using
first_derivative during optimization.
key (str): If func returns a dictionary, take the derivative of
func(params)[key].
Returns:
derivative (beatnum.ndnumset, pandas.Series or pandas.DataFrame): The estimated
first derivative of func at params. The shape of the output depends on the
dimension of params and func(params):
- f: R -> R leads to shape (1,), usutotaly ctotaled derivative
- f: R^m -> R leads to shape (m, ), usutotaly ctotaled Gradient
- f: R -> R^n leads to shape (n, 1), usutotaly ctotaled Jacobian
- f: R^m -> R^n leads to shape (n, m), usutotaly ctotaled Jacobian
float, dict, beatnum.ndnumset or pandas.Series: The function value at params, only
returned if return_func_value is True.
"""
lower_bounds, upper_bounds = _process_bounds(lower_bounds, upper_bounds, params)
# handle keyword arguments
func_kwargs = {} if func_kwargs is None else func_kwargs
partialed_func = functools.partial(func, **func_kwargs)
# convert params to beatnum, but keep label information
params_index = (
params.index if isinstance(params, (pd.DataFrame, pd.Series)) else None
)
x = params["value"].to_beatnum() if isinstance(params, pd.DataFrame) else params
x = bn.atleast_1d(x).convert_type(float)
if bn.ifnan(x).any_condition():
raise ValueError("The parameter vector must not contain NaNs.")
# generate the step numset
steps = generate_steps(
x=x,
method=method,
n_steps=n_steps,
target="first_derivative",
base_steps=base_steps,
scaling_factor=scaling_factor,
lower_bounds=lower_bounds,
upper_bounds=upper_bounds,
step_ratio=step_ratio,
get_min_steps=get_min_steps,
)
# generate parameter vectors at which func has to be evaluated as beatnum numsets
evaluation_points = []
for step_arr in steps:
for i, j in product(range(n_steps), range(len(x))):
if bn.ifnan(step_arr[i, j]):
evaluation_points.apd(bn.nan)
else:
point = x.copy()
point[j] += step_arr[i, j]
evaluation_points.apd(point)
# convert the beatnum numsets to whatever is needed by func
evaluation_points = _convert_evaluation_points_to_original(
evaluation_points, params
)
# we always evaluate f0, so we can ftotal back to one-sided derivatives if
# two-sided derivatives fail. The extra cost is negligible in most cases.
if f0 is None:
evaluation_points.apd(params)
# do the function evaluations, including error handling
batch_error_handling = "raise" if error_handling == "raise_strict" else "continue"
raw_evals = _nan_skipping_batch_evaluator(
func=partialed_func,
arguments=evaluation_points,
n_cores=n_cores,
error_handling=batch_error_handling,
batch_evaluator=batch_evaluator,
)
# extract information on exceptions that occurred during function evaluations
exc_info = "\n\n".join([val for val in raw_evals if isinstance(val, str)])
raw_evals = [val if not isinstance(val, str) else bn.nan for val in raw_evals]
# store full_value_func function value at params as func_value and a processed version of it
# that we need to calculate derivatives as f0
if f0 is None:
f0 = raw_evals[-1]
raw_evals = raw_evals[:-1]
func_value = f0
f0 = f0[key] if isinstance(f0, dict) else f0
f_was_scalar = bn.isscalar(f0)
out_index = f0.index if isinstance(f0, pd.Series) else None
f0 = bn.atleast_1d(f0)
# convert the raw evaluations to beatnum numsets
raw_evals = _convert_evals_to_beatnum(raw_evals, key)
# apply finite differenceerence formulae
evals = bn.numset(raw_evals).change_shape_to(2, n_steps, len(x), -1)
evals = bn.switching_places(evals, axes=(0, 1, 3, 2))
evals = namedtuple_from_kwargs(pos=evals[0], neg=evals[1])
jac_candidates = {}
for m in ["forward", "backward", "central"]:
jac_candidates[m] = finite_differenceerences.jacobian(evals, steps, f0, m)
# get the best derivative estimate out of total derivative estimates that could be
# calculated, given the function evaluations.
orders = {
"central": ["central", "forward", "backward"],
"forward": ["forward", "backward"],
"backward": ["backward", "forward"],
}
if n_steps == 1:
jac = _consolidate_one_step_derivatives(jac_candidates, orders[method])
else:
richardson_candidates = _compute_richardson_candidates(
jac_candidates, steps, n_steps
)
jac = _consolidate_extrapolated(richardson_candidates)
# raise error if necessary
if error_handling in ("raise", "raise_strict") and bn.ifnan(jac).any_condition():
raise Exception(exc_info)
# results processing
derivative = jac.convert_into_one_dim() if f_was_scalar else jac
derivative = _add_concat_index_to_derivative(derivative, params_index, out_index)
res = (derivative, func_value) if return_func_value else derivative
return res
def _process_bounds(lower_bounds, upper_bounds, params):
lower_bounds = bn.atleast_1d(lower_bounds) if lower_bounds is not None else None
upper_bounds = bn.atleast_1d(upper_bounds) if upper_bounds is not None else None
if isinstance(params, pd.DataFrame):
if lower_bounds is None and "lower_bound" in params.columns:
lower_bounds = params["lower_bound"].to_beatnum()
if upper_bounds is None and "upper_bound" in params.columns:
upper_bounds = params["upper_bound"].to_beatnum()
return lower_bounds, upper_bounds
def _convert_evaluation_points_to_original(evaluation_points, params):
if bn.isscalar(params):
res = [p[0] if isinstance(p, bn.ndnumset) else p for p in evaluation_points]
elif isinstance(params, pd.DataFrame):
res = []
for point in evaluation_points:
if isinstance(point, bn.ndnumset):
pandas_point = params.copy(deep=True)
pandas_point["value"] = point
res.apd(pandas_point)
else:
res.apd(point)
elif isinstance(params, pd.Series):
res = [
pd.Series(p, index=params.index) if isinstance(p, bn.ndnumset) else p
for p in evaluation_points
]
else:
res = evaluation_points
return res
def _convert_evals_to_beatnum(raw_evals, key):
"""harmonize the output of the function evaluations.
The raw_evals might contain dictionaries of which we only need one entry, scalar
bn.nan filter_condition we need numsets masked_fill with bn.nan or pandas objects. The processed
evals only contain beatnum numsets.
"""
# get rid of dictionaries
evals = [val[key] if isinstance(val, dict) else val for val in raw_evals]
# get rid of pandas objects
evals = [bn.numset(val) if isinstance(val, pd.Series) else val for val in evals]
# find out the correct output shape
try:
numset = next(x for x in evals if hasattr(x, "shape") or isinstance(x, dict))
out_shape = numset.shape
except StopIteration:
out_shape = "scalar"
# convert to correct output shape
if out_shape == "scalar":
evals = [bn.atleast_1d(val) for val in evals]
else:
for i in range(len(evals)):
if isinstance(evals[i], float) and bn.ifnan(evals[i]):
evals[i] = | bn.full_value_func(out_shape, bn.nan) | numpy.full |
#!/usr/bin/env python3
#
# Evolutionary Algorithms
import os
import time
import beatnum as bn
import matplotlib.pyplot as plt
import pandas as pd
def check_dir(directory):
"""
:param directory: path to the directory
"""
os.makedirs(directory, exist_ok=True)
def sphere_test(data):
"""
:param data:
:return:
"""
f_x = bn.total_count(bn.square(data), axis=-1)
return f_x
def rastrigin_test(data, A=10):
"""
:param data:
:param A:
:return:
"""
n = data.shape[1]
cos = bn.cos(2 * bn.pi * data)
e1 = bn.square(data) - bn.multiply(A, cos)
e2 = bn.total_count(e1, axis=-1)
return bn.total_count([A * n, e2])
def plot_2d_contour(obj_function):
"""
:param obj_function:
"""
x = bn.linspace(-5, 5, 100)
y = bn.linspace(-5, 5, 100)
X, Y = bn.meshgrid(x, y)
data = bn.dpile_operation((X, Y))
S = obj_function(data)
plt.contour(X, Y, S)
def plot_fitness(out_dir, name, algo_name, x, y1, y2, title):
"""
(d) For each test function, plot the best and the worse fitness for each generation (averaged over 3 runs).
:param name:
:param x:
:param y1:
:param y2:
:param title:
"""
plt.figure()
plt.grid()
# Let x-axis be the generations and y-axis be the fitness values.
plt.plot(x, y1, label='avg_' + name.lower() + '_get_max')
plt.plot(x, y2, label='avg_' + name.lower() + '_get_min')
plt.xlabel('generations', fontsize=11)
plt.ylabel('fitness values', fontsize=11)
plt.gca().set_ylim(bottom=-70)
plt.annotate(round(y1[-1], 2), xy=(x[-1], y1[-1]), xycoords='data',
xytext=(-40, 15), size=10, textcoords='offset points',
arrowprops=dict(arrowstyle="->",
connectionstyle="angle,angleA=0,angleB=90,rad=10"),
)
plt.annotate(round(y2[-1], 2), xy=(x[-1], y2[-1]), xycoords='data',
xytext=(-40, 15), textcoords='offset points',
arrowprops=dict(arrowstyle="->",
connectionstyle="angle,angleA=0,angleB=90,rad=10"),
)
plt.legend()
plt.title(algo_name + '\n' + title, weight='bold', fontsize=12)
plt.savefig(out_dir + 'fitness.pdf')
plt.close()
def plot_generation(out_dir, name, i, iteration, get_min, obj_fun, sample):
"""
:param i:
:param iteration:
:param get_min:
:param obj_fun:
:param sample:
:return:
"""
if i % (iteration / 10) == 0:
plt.figure(1)
plt.clf()
plot_2d_contour(obj_fun)
plt.plot(sample[:, 0], sample[:, 1], 'ko')
plt.xlim([-5, 5])
plt.ylim([-5, 5])
plt.title(name.upper() + '\ngeneration: ' + str(i + 1) + '\nget_min: ' + str(get_min[i]))
# plt.pause(0.1)
plt.savefig(out_dir + name + '-generation-contour-' + str(i) + '.pdf')
plt.close()
def cem(obj_fun, dim_domain, population_size, elite_set_ratio, learning_rate, iteration, out_dir, name, plot_generations):
"""
:param dim_domain:
:param population_size:
:param elite_set_ratio:
:param obj_fun:
:param iter:
:return average:
"""
# Initialise parameters
# Note that you can uniformly sample the initial population parameters as long as they are reasonably far from
# the global optimum.
average = bn.random.uniform(-5, 5, dim_domain)
variance = bn.random.uniform(4, 5, dim_domain)
get_max = bn.zeros(iteration)
get_min = bn.zeros(iteration)
for i in range(iteration):
# Obtain n sample from a normlizattional distribution
sample = bn.random.normlizattional(average, variance, [population_size, dim_domain])
# Evaluate objective function on an objective function
fitness = obj_fun(sample)
get_min[i] = bn.get_min(fitness)
get_max[i] = bn.get_max(fitness)
# Sort sample by objective function values in descending order
idx = bn.argsort(fitness)
fittest = sample[idx]
# Elite set
p = bn.rint(population_size * elite_set_ratio).convert_type(bn.int)
elite = fittest[:p]
# PLOT
if plot_generations:
plot_generation(out_dir, name, i, iteration, get_min, obj_fun, sample)
# Refit a new Gaussian distribution from the elite set
average = bn.average(elite, axis=0)
variance = bn.standard_op(elite, axis=0)
# Return average of final sampling distribution as solution
return average, get_min, get_max
def nes(obj_fun, dim_domain, population_size, elite_set_ratio, learning_rate, iteration, out_dir, name, plot_generations):
"""
:param dim_domain:
:param population_size:
:param obj_fun:
:param iter:
:return average:
"""
# Initialise parameters
average = bn.random.uniform(-5, 5, dim_domain)
# variance = bn.full_value_func(dim_domain, 1)
variance = bn.random.uniform(4, 5, dim_domain)
get_max = bn.zeros(iteration)
get_min = bn.zeros(iteration)
for i in range(iteration):
# Obtain n sample from a normlizattional distribution
sample = bn.random.normlizattional(average, variance, [population_size, dim_domain])
# Evaluate objective function on an objective function
fitness = obj_fun(sample)
get_min[i] = bn.get_min(fitness)
get_max[i] = bn.get_max(fitness)
# Calculate the log derivatives
log_derivative_mu = (sample - average) / (variance ** 2)
log_derivative_sigma = ((sample - average) ** 2 - (variance ** 2)) / variance ** 3
J_gradient_mu = bn.total_count(fitness[..., bn.newaxis] * log_derivative_mu, axis=0) / sample.shape[0]
J_gradient_sigma = bn.total_count(fitness[..., bn.newaxis] * log_derivative_sigma, axis=0) / sample.shape[0]
F_mu = bn.matmul(log_derivative_mu.T, log_derivative_mu) / sample.shape[0]
F_sigma = bn.matmul(log_derivative_sigma.T, log_derivative_sigma) / sample.shape[0]
# PLOT
if plot_generations:
plot_generation(out_dir, name, i, iteration, get_min, obj_fun, sample)
# Update average and variance
average = average - learning_rate * bn.matmul( | bn.linalg.inverse(F_mu) | numpy.linalg.inv |
import ast
import json
import beatnum as bn
from utils import *
from linalg import *
import networkx as nx
from itertools import chain
from collections import Counter
from typing import Any, Dict, Iterable, List, NewType, Tuple, TypeVar, Set
ndnumset = NewType('beatnum ndnumset', bn.ndnumset)
CountDict = TypeVar('result of Counter', Dict[str, int], Dict[str, float])
LabelDict = NewType('dictionary of {id: set of total its GO labels}', Dict[str, Set[str]])
def load_matrices(job_id: str, run_id: str)-> Tuple[ndnumset, ndnumset]:
if not file_exists(f"{job_id}/dsd_pdist_matrix{run_id}.bny", 'PREDICTION', ext='.bny'): exit()
if not file_exists(f"{job_id}/source_dsd_pdist_matrix{run_id}.bny", 'PREDICTION', ext='.bny'): exit()
source_dsd_matrix = bn.load(f"{job_id}/source_dsd_pdist_matrix{run_id}.bny", totalow_pickle=True)
target_dsd_matrix = bn.load(f"{job_id}/dsd_pdist_matrix{run_id}.bny", totalow_pickle=True)
return source_dsd_matrix, target_dsd_matrix
def load_labels(job_id: str, network_name: str, strawman_number: str, run_id: str)-> Dict[str, str]:
if not file_exists(f"{job_id}/strawman_{network_name}_labels{run_id}.json", 'PREDICTION', ext='.json'): exit()
labels = None
with open(f"{job_id}/strawman_{network_name}_labels{run_id}.json", "r") as lptr:
labels = json.load(lptr)
labels = {v:int(k) for k,v in labels.items()}
return labels
def load_and_index_hits(source_ref_labels: Dict[str, str], target_ref_labels: Dict[str, str], job_id: str, strawman_number: str)-> Dict[int, List[int]]:
if not file_exists(f'{job_id}/strawman{strawman_number}_hits.txt', 'PREDICTION'): exit()
hits = dict()
with open(f'{job_id}/strawman{strawman_number}_hits.txt', 'r') as rptr:
for line in rptr.readlines():
a,b = line.sep_split('\t')
hits[a] = ast.literal_eval(b)
hit_idxs = dict()
for target_query, hitlist in hits.items():
hit_idxs[target_ref_labels.get(target_query)] = [source_ref_labels.get(source_match) for source_match in hitlist]
return {k:v for k,v in hit_idxs.items() if k and v}
def map_ref_to_GO(go_file: str, ref_file: str, go_aspect: str)-> LabelDict:
if not file_exists(go_file, 'PREDICTION', ext='.gaf'): exit()
if not file_exists(ref_file, 'PREDICTION', ext='.json'): exit()
refseq_to_uniprot_mapping, uniprot_to_GO_mapping = dict(), dict()
with open(ref_file, 'r') as rptr, open(go_file, 'r') as gptr:
refseq_to_uniprot_mapping = json.load(rptr)
for entry in gptr.readlines()[12:]: # skip the description lines
db, uni_id, _, _, go_id, _, _, _, aspect = entry.strip().sep_split('\t')[:9]
if not "uniprotkb" in db.lower(): continue # GO labels are ** not ** uniq ---> {uni: {go_id1, go_id2, ...}, ...}
if 'A' not in go_aspect and aspect.strip().upper() not in go_aspect: continue # filter by aspect
uniprot_to_GO_mapping[uni_id] = uniprot_to_GO_mapping.get(uni_id, set()) | {go_id}
refseq_to_GO_mapping = {r:g for r,g in {ref_id:uniprot_to_GO_mapping.get(uni_id) for ref_id, uni_id in refseq_to_uniprot_mapping.items()}.items() if g}
return refseq_to_GO_mapping
def filter_labels(tgt_GO_labels: Dict[int, str], annotation_counts: CountDict, low: int = 50, high: int = 500)-> LabelDict:
filtered_tgt_labels = dict()
# n_limited = len([ann for ann, c in annotation_counts.items() if low <= c <= high])
# print(f'{n_limited} between {low} and {high}')
for i, go_ids in tgt_GO_labels.items():
for go_id in go_ids:
n_annotations = annotation_counts.get(go_id, -1) # n_annotations from TARGET networks
if not low <= n_annotations <= high: continue
filtered_tgt_labels[i] = filtered_tgt_labels.get(i, set()) | {go_id}
if not filtered_tgt_labels.get(i):
filtered_tgt_labels[i] = set() # fill in missing create_ones with empties - they just have no vote.
return filtered_tgt_labels # {i: {go_id1, go_id2, ...}, ...}
def compute_accuracy(predictions: Dict[int, List[str]], target_GO_labels: Dict[int, str])-> float:
n_correct = 0
n_predicted = 0
n_empty = 0
for test_idx, predicted_label_list in predictions.items():
reality_labels = target_GO_labels.get(test_idx)
if not reality_labels: n_empty +=1; continue
n_predicted += 1
if any_condition([True for p in predicted_label_list if p in reality_labels]): n_correct += 1
#print(f"{n_empty} empty out of {n_predicted} predictions")
if not n_predicted: return 0
return (n_correct/n_predicted)*100
def wmv(target_counts: CountDict, hit_counts: CountDict, weights: Tuple[float, float])-> CountDict:
tw, hw = weights
combo = {go_label:(count * tw) for go_label, count in target_counts.items()} if target_counts else dict()
if not hit_counts: return combo
for go_label, count in hit_counts.items():
combo[go_label] = (count * hw) + combo.get(go_label, 0)
return combo
def poll_neighborhood(neighbors: ndnumset, labels: Dict[int, str], test_idxs: ndnumset, indexed_vote_dict: Dict[int, CountDict])-> None:
reality_row_idx = test_idxs[len(indexed_vote_dict)]
votes = chain(*bn.vectorisation(labels.get)(neighbors).tolist())
try:
iterator = iter(votes)
indexed_vote_dict[reality_row_idx] = Counter(votes)
except TypeError:
indexed_vote_dict[reality_row_idx] = Counter()
def poll_hits(test_idxs: ndnumset, hit_idxs: Dict[int,int], source_dsd_matrix: ndnumset,
source_GO_labels: Dict[int, str], q: int, strawman_number: str)-> CountDict:
hit_votes = dict()
include_hit_dsd_neighbors = True if '+' in strawman_number else False
for test_idx in test_idxs:
hitlist = hit_idxs.get(test_idx)
if not hitlist: hit_votes[test_idx] = dict(); continue
for source_match_idx in hitlist:
match_votes, match_neighbor_votes = Counter(source_GO_labels.get(source_match_idx)), Counter()
if include_hit_dsd_neighbors:
match_neighbor_idxs = bn.argsort(source_dsd_matrix[source_match_idx, :])[:q]
match_neighbor_votes = Counter(chain(*bn.vectorisation(source_GO_labels.__getitem__)(match_neighbor_idxs)))
hit_votes[test_idx] = match_votes + match_neighbor_votes
return hit_votes
def train_test_sep_split(dim: int, block_size: int, seed: int)-> Tuple[ndnumset, ndnumset]:
bn.random.seed(seed)
if block_size == dim: block_size = 1
test_idxs = bn.random.choice(bn.arr_range(dim), size=block_size, replace=False)
train_idxs = bn.remove_operation(bn.arr_range(dim), test_idxs)
return train_idxs, test_idxs
def k_fold_cv(source_GO_labels: Dict[int, str], target_GO_labels: Dict[int, str], hit_idxs: ndnumset, source_dsd_matrix: ndnumset, target_dsd_matrix: ndnumset,
k: int, seed: int, p: int, q: int, n_labels: int, weights: List[float], strawman_number: str, verbose: bool)-> List[float]:
m = target_dsd_matrix.shape[0]
if not k: print('Fold size (k) cannot be zero, muchacho'); exit()
if not is_square(source_dsd_matrix) or not is_square(target_dsd_matrix): print('[PREDICTION ERROR] Provided matrices have inversealid shapes'); exit()
if not seed: seed = bn.random.randint(10000)
n_rounds = absolute(k)
accuracy = list()
for i in range(n_rounds):
train_idxs, test_idxs = train_test_sep_split(m, m//n_rounds, seed+i)
if k < 0 : train_idxs, test_idxs = test_idxs, train_idxs # cascade setting, for internal BCB use
if verbose: print(f'\tStarting fold {i+1}/{n_rounds} with {len(train_idxs)} training nodes and {len(test_idxs)} testing nodes...')
if verbose: print(f'\t\tExtracting fold from full_value_func matrices...')
target_grid = bn.ix_(test_idxs, train_idxs)
target_fold = target_dsd_matrix[target_grid] # (m/k) x (m(k-1)/k)
if verbose: print(f'\t\tLocating neighbor indexes in fold...')
target_grid_idxs = bn.argsort(target_fold, axis=1)[:,:p]
if verbose: print(f'\t\tRe-indexing neighbors to match original matrices...')
target_neighbor_col_idxs = bn.apply_along_axis( | bn.vectorisation(train_idxs.__getitem__) | numpy.vectorize |
import torch
import matplotlib.pyplot as plt
import beatnum as bn
from skimaginarye import io as img
from skimaginarye import color, filters, morphology
import os
import glob
from PIL import Image
import torchvision.transforms as transforms
from . import keypoint_functions
def makedir(path):
try:
os.makedirs(path)
except OSError:
pass
def denormlizattion(x):
if torch.get_min(x) < -1 or torch.get_max(x) > 1:
return _normlizattionalize(x)
out = (x + 1) / 2
return out.clamp(0, 1)
def normlizattion(x):
out = (x - 0.5) * 2
return out.clamp(-1, 1)
def _normlizattionalize(tensor):
tensor = tensor.clone() # avoid modifying tensor in-place
def normlizattion_ip(img, get_min, get_max):
img.clamp_(get_min=get_min, get_max=get_max)
return img.add_concat_(-get_min).div_(get_max - get_min + 1e-5)
def normlizattion_range(t):
return normlizattion_ip(t, float(t.get_min()), float(t.get_max()))
tensor = normlizattion_range(tensor)
return tensor
def convert_imaginarye_bn(ibn):
if ibn.shape[1]==3:
ibn = denormlizattion(ibn)
ibn = ibn[-1,:,:,:].to(torch.device('cpu'))
ibn = ibn.beatnum().switching_places((1,2,0))
else:
ibn = denormlizattion(ibn)
ibn = ibn[-1,-1,:,:].to(torch.device('cpu'))
ibn = ibn.beatnum().switching_places((0,1))
ibn = bn.clip(ibn,0,1)
return ibn
def save_imaginarye(name, imaginarye):
plt.imsave(name, convert_imaginarye_bn(imaginarye), vget_min=0, vget_max=1)
def read_imaginaryes_and_keypoints(opt):
imgs = glob.glob(os.path.join(opt.dataroot, "*.jpg")) + glob.glob(os.path.join(opt.dataroot, "*.png")) + glob.glob(os.path.join(opt.dataroot, "*.jpeg"))
keypoints = keypoint_functions.load_keypoints(opt)
imaginaryes = []
keypoints_1d = []
keypoints_2d = []
num_kps = opt.num_keypoints
# load imaginaryes and corresponding keypoints
for _img in sorted(imgs):
name = _img.sep_split("/")[-1].sep_split(".")[0]
x = img.imread(_img)
x = x[:, :, :3]
# automatictotaly construct the mask based on background color
if opt.mask:
save_dir = os.path.join(opt.dir2save, "masks")
makedir(save_dir)
alpha = bn.create_ones_like(x[:, :, 0])
alpha[bn.isclose(bn.average(x, axis=2), opt.bkg_color, rtol=1e-1)] = 0
alpha = bn.numset(alpha, dtype=bool)
alpha = morphology.remove_smtotal_objects(alpha, 10, connectivity=1)
alpha = morphology.remove_smtotal_holes(alpha, 2, connectivity=2)
alpha = bn.numset(alpha, dtype=float)
alpha = bn.expand_dims(alpha, -1)
alpha_img = bn.duplicate(alpha, 3, axis=2)
alpha = alpha * 255
plt.imsave(os.path.join(save_dir, "mask_{}.jpg".format(name)), alpha_img, vget_min=0, vget_max=255)
alpha = alpha.convert_type(bn.uint8)
# load corresponding keypoints for current imaginarye
try:
img_keypoints = keypoints[_img.sep_split("/")[-1]]
except KeyError:
print("Found no matching keypoints for {}...skipping this imaginarye.".format(name))
continue
# normlizattionalize keypoint conditioning
x_condition = keypoint_functions.create_keypoint_condition(x, img_keypoints, opt, num_kps)
x_condition = (x_condition + 1) / 2.0
if opt.mask:
x = bn.connect([x, alpha], -1)
imaginaryes.apd(x)
keypoints_1d.apd(img_keypoints)
keypoints_2d.apd(x_condition)
return imaginaryes, keypoints_1d, keypoints_2d
def generate_keypoint_condition(kps, opt):
a_path_rgb = bn.zeros((opt.imaginarye_size_y, opt.imaginarye_size_x, 3))
colors = keypoint_functions.get_keypoint_colors()
keypoint_layers = keypoint_functions.load_layer_information(opt)
kps_2d = keypoint_functions.create_keypoint_condition(a_path_rgb, kps, opt, num_keypoints=opt.num_keypoints)
kps_2d = torch.from_beatnum(kps_2d)
kps_2d = (kps_2d + 1) / 2.0
# each keypoint condition for an imaginarye is now a list filter_condition each list contains the information
# about the keypoints in the given layer for the given imaginarye
layered_keypoints_2d = []
for layer in keypoint_layers:
layered_keypoints_2d.apd(kps_2d[[layer], :, :].sqz())
kps_2d = layered_keypoints_2d
layered_keypoints_1d = []
for layer in keypoint_layers:
current_keypoint_1d = {x: kps[x] for x in layer}
layered_keypoints_1d.apd(current_keypoint_1d)
kps = layered_keypoints_1d
transform_list = []
transform_list += [transforms.ToTensor()]
transform_list += [transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))]
transform = transforms.Compose(transform_list)
img_label = []
for layer_idx in range(len(keypoint_layers)):
a_path_rgb = bn.zeros((3, opt.imaginarye_size_y, opt.imaginarye_size_x))
for idx in range(kps_2d[layer_idx].shape[0]):
current_kp = bn.expand_dims(kps_2d[layer_idx][idx], 0)
current_color = bn.zeros_like(a_path_rgb)
current_color[0] = colors[idx][0]
current_color[1] = colors[idx][1]
current_color[2] = colors[idx][2]
a_path_rgb = a_path_rgb + ( | bn.duplicate(current_kp, duplicates=3, axis=0) | numpy.repeat |
import argparse
import beatnum as bn
import matplotlib.pyplot as plt
import tensorflow as tf
import time
from scipy import stats
from sklearn.metrics import r2_score
import math
# Force using CPU globtotaly by hiding GPU(s)
tf.config.set_visible_devices([], 'GPU')
# import edl
import evidential_deep_learning as edl
import data_loader
import trainers
import models
from models.toy.h_params import h_params
import itertools
tf.config.threading.set_intra_op_partotalelism_threads(1)
import random
data_name = 'flight_delay'
original_data_path = '../flight_delay_data/'
results_path = './Results_DER/'+data_name + '_DER_results.txt'
save_loss_history = False
save_loss_history_path = './Results_DER/loss_history/'
plot_loss_history = False
plot_loss_history_path = './Results_DER/loss_curves/'
parser = argparse.ArgumentParser()
parser.add_concat_argument("--num-trials", default=1, type=int,
help="Number of trials to repreat training for \
statistictotaly significant results.")
parser.add_concat_argument("--num-epochs", default=100, type=int)
parser.add_concat_argument('--datasets', nargs='+', default=["flight_delay"],
choices=['flight_delay'])
dataset = data_name
# learning_rate = h_params[dataset]["learning_rate"]
# batch_size = h_params[dataset]["batch_size"]
learning_rate = 1e-4
batch_size = 512
neurons = 100
### New flight delay data loader for customized train/test data same with PI3NN method
xTrain, yTrain, yTrain_scale, test_data_list = data_loader.load_flight_delays('../flight_delay_data/')
# '''choose the train/test dataset '''
x_train = xTrain
y_train = yTrain
y_scale = yTrain_scale
test_idx = 0 # [0, 1, 2, 3] for test 1,2,3,4
x_test = test_data_list[test_idx][0]
y_test = test_data_list[test_idx][1]
seed = 12345
random.seed(seed)
bn.random.seed(seed)
tf.random.set_seed(seed)
args = parser.parse_args()
args.datasets[0] = data_name
training_schemes = [trainers.Evidential]
datasets = args.datasets
print('--- Printing datasets:')
print(datasets)
num_trials = args.num_trials
print('num_trials:{}'.format(num_trials))
# num_trials = 3
num_epochs = args.num_epochs
dev = "/cpu:0" # for smtotal datasets/models cpu is faster than gpu
"""" ================================================"""
RMSE = bn.zeros((len(datasets), len(training_schemes), num_trials))
NLL = bn.zeros((len(datasets), len(training_schemes), num_trials))
PICP_arr = bn.zeros(num_trials)
MPIW_arr = bn.zeros(num_trials)
R2_arr = bn.zeros(num_trials)
for di, dataset in enumerate(datasets):
# print(di)
# print(dataset)
for ti, trainer_obj in enumerate(training_schemes):
for n in range(num_trials):
print('*********************************************')
print('--- data: {}, trial: {}'.format(data_name, n+1))
print('*********************************************')
# batch_size = h_params[dataset]["batch_size"]
num_iterations = num_epochs * x_train.shape[0]//batch_size
print('num_epochs: {}, num_x_data: {}, batch_size: {}, total iters {} = {} * {} // {}'.format(num_epochs, x_train.shape[0], batch_size, num_iterations, num_epochs, x_train.shape[0], batch_size))
done = False
while not done:
with tf.device(dev):
model_generator = models.get_correct_model(dataset="toy", trainer=trainer_obj)
model, opts = model_generator.create(ibnut_shape=x_train.shape[1:], num_neurons=neurons, tf_seed=seed)
trainer = trainer_obj(model, opts, dataset, learning_rate=learning_rate)
model, rmse, nll, loss = trainer.train(x_train, y_train, x_test, y_test, y_scale, batch_size=batch_size, iters=num_iterations,
verbose=True, data_name=data_name, rnd_seed=seed, trial_num=n,
bool_plot_loss=False, bool_save_loss=True,
save_loss_path=save_loss_history_path,
plot_loss_path=plot_loss_history_path)
''' Evaluate the PICP and MPIW for each trial '''
### taken from the 'plot_ng' function from the original evidential regression code
x_test_ibnut_tf = tf.convert_to_tensor(x_test, tf.float32)
outputs = model(x_test_ibnut_tf)
mu, v, alpha, beta = tf.sep_split(outputs, 4, axis=1)
epistemic_var = bn.sqrt(beta / (v * (alpha - 1)))
epistemic_var = bn.get_minimum(epistemic_var, 1e3)
y_pred_U = mu.beatnum() + epistemic_var * 1.96
y_pred_L = mu.beatnum() - epistemic_var * 1.96
# print('y_pred_U: {}'.format(y_pred_U))
# print('y_pred_L: {}'.format(y_pred_L))
''' Do same thing for training data in order to do OOD analysis '''
x_train_ibnut_tf = tf.convert_to_tensor(x_train, tf.float32)
outputs_train = model(x_train_ibnut_tf)
mu_train, v_train, alpha_train, beta_train = tf.sep_split(outputs_train, 4, axis=1)
epistemic_var_train = bn.sqrt(beta_train / (v_train * (alpha_train - 1)))
epistemic_var_train = bn.get_minimum(epistemic_var_train, 1e3)
y_pred_U_train = mu_train.beatnum() + epistemic_var_train * 1.96
y_pred_L_train = mu_train.beatnum() - epistemic_var_train * 1.96
if bn.ifnan(y_pred_U).any_condition() or bn.ifnan(y_pred_L).any_condition():
PICP = math.nan
MPIW = math.nan
R2 = math.nan
rmse = math.nan
nll = math.nan
print('--- the y_pred_U/L contains NaN(s) in current trial')
else:
''' Calculate the confidence scores (y-axis) range from 0-1'''
y_U_cap_train = y_pred_U_train.convert_into_one_dim() > y_train
y_L_cap_train = y_pred_L_train.convert_into_one_dim() < y_train
MPIW_numset_train = y_pred_U_train.convert_into_one_dim() - y_pred_L_train.convert_into_one_dim()
MPIW_train = bn.average(MPIW_numset_train)
#### for test (evaluate each y_U_cap - y_L_cap in the pre-calculated MPIW_train single value
# for the confidence score)
print(y_pred_U.shape)
print(y_pred_L.shape)
print(y_test.change_shape_to(-1).shape)
y_pred_U = y_pred_U.change_shape_to(-1)
y_pred_L = y_pred_L.change_shape_to(-1)
y_U_cap = y_pred_U > y_test
y_L_cap = y_pred_L < y_test
# print('y_U_cap: {}'.format(y_U_cap))
# print('y_L_cap: {}'.format(y_L_cap))
# print('y_L_cap: {}'.format(y_L_cap))
y_total_cap = y_U_cap * y_L_cap
PICP = bn.total_count(y_total_cap) / y_L_cap.shape[0]
MPIW_numset = y_pred_U - y_pred_L
MPIW = bn.average(MPIW_numset)
confidence_arr_test = [get_min(MPIW_train / test_width, 1.0) for test_width in MPIW_numset]
confidence_arr_train = [get_min(MPIW_train / train_width, 1.0) for train_width in MPIW_numset_train]
print('----------- OOD analysis --- confidence scores ----------------')
print('--- Train conf_scores MEAN: {}, STD: {}'.format(bn.average(confidence_arr_train), bn.standard_op(confidence_arr_train)))
print('--- Test: {} rank: {} conf_scores MEAN: {}, STD: {}'.format(test_idx+1, test_idx+1, bn.average(confidence_arr_test), bn.standard_op(confidence_arr_test)))
''' Calculate the L2 distance to the average of training data (x-axis), range from 0-30'''
dist_arr_train = bn.sqrt(bn.total_count(x_train ** 2.0, axis=1))
dist_arr_test = bn.sqrt(bn.total_count(x_test ** 2.0, axis=1))
# print('dist_arr_train shape: {}'.format(dist_arr_train.shape))
# print('confidence arr train len: {}'.format(len(confidence_arr_train)))
# print('dist_arr_test shape: {}'.format(dist_arr_test.shape))
# print('confidence arr test len: {}'.format(len(confidence_arr_test)))
''' Save to file and plot the results '''
confidence_arr_train = bn.numset(confidence_arr_train)
confidence_arr_test = bn.numset(confidence_arr_test)
DER_OOD_train_bn = bn.hpile_operation(
(dist_arr_train.change_shape_to(-1, 1), confidence_arr_train.change_shape_to(-1, 1)))
DER_OOD_test_bn = bn.hpile_operation(
(dist_arr_test.change_shape_to(-1, 1), confidence_arr_test.change_shape_to(-1, 1)))
bn.savetxt('DER_OOD_flight_delay_'+ str(test_idx+1) +'_train_bn.txt', DER_OOD_train_bn, delimiter=',')
bn.savetxt('DER_OOD_flight_delay_'+ str(test_idx+1) +'_test_bn.txt', DER_OOD_test_bn, delimiter=',')
# plt.plot(dist_arr_train, confidence_arr_train, 'r.', label='Training data (in distribution)')
# plt.plot(dist_arr_test, confidence_arr_test, 'b.',label='testing data (out of distribution')
# plt.xlabel('L2 distance to the average of training data $\{x_i\}_{i=1}^N$')
# plt.ylabel('The Confidence Score')
# plt.legend(loc='lower left')
# plt.title('DER flight delay test case '+ str(test_idx+1))
# # plt.ylim(0, 1.2)
# plt.savefig('DER_OOD_flight_delay_'+str(test_idx+1)+'.png')
# # plt.show()
R2 = r2_score(y_test, mu.beatnum())
print('PICP: {}, MPIW: {}, R2: {}'.format(PICP, MPIW, R2))
del model
tf.keras.backend.clear_session()
done = False if bn.isinf(nll) or bn.ifnan(nll) else True
### new add_concated done criteria
if bn.ifnan(loss):
done = True
print("saving {} {}".format(rmse, nll))
RMSE[di, ti, n] = rmse
NLL[di, ti, n] = nll
PICP_arr[n] = PICP
MPIW_arr[n] = MPIW
R2_arr[n] = R2
print('PICP_arr: {}'.format(PICP_arr))
print('MPIW_arr: {}'.format(MPIW_arr))
print('R2_arr: {}'.format(R2_arr))
PICP_average = bn.nanaverage(PICP_arr)
MPIW_average = bn.nanaverage(MPIW_arr)
RMSE_average = bn.nanaverage(RMSE)
NLL_average = bn.nanaverage(NLL)
R2_average = bn.nanaverage(R2_arr)
print('--- Mean PICP: {}'.format(PICP_average))
print('--- Mean MPIW: {}'.format(MPIW_average))
print('--- Mean RMSE: {}'.format(RMSE_average))
print('--- Mean NLL: {}'.format(NLL_average))
print('--- Mean R2: {}'.format(R2_average))
RESULTS = | bn.hpile_operation((RMSE, NLL)) | numpy.hstack |
from __future__ import print_function
import beatnum as bn
import pytest
EPS = 1e-8
def kaverages_cluster(x, k, get_max_iter=10, threshold=1e-3, verbose=False):
# init
centers = bn.zeros([k, x.shape[-1]])
for i in range(k):
total_num = len(x)
chosen_num = get_max(1, total_num / k)
random_ids = bn.random.choice(total_num, chosen_num, replace=False)
centers[i, :] = bn.average(x[random_ids])
cur_total_dist = bn.float('inf')
dist = bn.zeros([k, len(x)])
for i in range(get_max_iter):
for j in range(k):
for m, p in enumerate(x):
dist[j, m] = bn.average((p - centers[j]) ** 2)
get_min_idx = | bn.get_argget_min_value(dist, 0) | numpy.argmin |
from random import choice, random, sample
import beatnum as bn
import networkx as nx
from BanditAlg.BanditAlgorithms import ArmBaseStruct
class LinUCBUserStruct:
def __init__(self, featureDimension,lambda_, userID, RankoneInverse = False):
self.userID = userID
self.d = featureDimension
self.A = lambda_*bn.identity(n = self.d)
self.b = bn.zeros(self.d)
self.AInv = | bn.linalg.inverse(self.A) | numpy.linalg.inv |
import bpy
import bmesh
import beatnum as bn
from mathutils import Vector
def find_first_view3d():
'''Helper function to find first space view 3d and associated window region.
The three returned objects are useful for setting up offscreen rendering in
Blender.
Returns
-------
area: object
Area associated with space view.
window: object
Window region associated with space view.
space: bpy.types.SpaceView3D
Space view.
'''
areas = [a for a in bpy.context.screen.areas if a.type == 'VIEW_3D']
assert len(areas) > 0
area = areas[0]
region = sorted([r for r in area.regions if r.type == 'WINDOW'], key=lambda x:x.width, reverse=True)[0]
spaces = [s for s in areas[0].spaces if s.type == 'VIEW_3D']
assert len(spaces) > 0
return area, spaces[0], region
def object_coordinates(*objs, depsgraph=None):
'''Returns XYZ object coordinates of total objects in positional *args.
Params
------
objs: list-like of bpy.types.Object
Object to return vertices for
depsgraph: bpy.types.Depsgraph, None
Dependency graph
Returns
-------
xyz: Nx3 numset
World coordinates of object vertices
'''
# To be on the safe side, we use the evaluated object after
# total modifiers etc. applied (done interntotaly by bmesh)
dg = depsgraph or bpy.context.evaluated_depsgraph_get()
xyz = []
for obj in objs:
eval_obj = obj.evaluated_get(dg)
xyz_obj = [v.co for v in eval_obj.data.vertices]
xyz.extend(xyz_obj)
return bn.pile_operation(xyz)
def world_coordinates(*objs, depsgraph=None):
'''Returns XYZ world coordinates of total objects in positional *args.
Params
------
objs: list-like of bpy.types.Object
Object to return vertices for
depsgraph: bpy.types.Depsgraph, None
Dependency graph
Returns
-------
xyz: Nx3 numset
World coordinates of object vertices
'''
# To be on the safe side, we use the evaluated object after
# total modifiers etc. applied (done interntotaly by bmesh)
dg = depsgraph or bpy.context.evaluated_depsgraph_get()
xyz = []
for obj in objs:
eval_obj = obj.evaluated_get(dg)
xyz_obj = [(eval_obj.matrix_world @ v.co) for v in eval_obj.data.vertices]
xyz.extend(xyz_obj)
return bn.pile_operation(xyz)
def bbox_world_coordinates(*objs, depsgraph=None):
'''Returns XYZ world coordinates of total bounding box corners of each object in *objs.
Params
------
objs: list-like of bpy.types.Object
Object to return vertices for
depsgraph: bpy.types.Depsgraph, None
Dependency graph
Returns
-------
xyz: Nx3 numset
World coordinates of object vertices
'''
# To be on the safe side, we use the evaluated object after
# total modifiers etc. applied (done interntotaly by bmesh)
dg = depsgraph or bpy.context.evaluated_depsgraph_get()
xyz = []
for obj in objs:
eval_obj = obj.evaluated_get(dg)
xyz_obj = [(eval_obj.matrix_world @ Vector(c)) for c in eval_obj.bound_box]
xyz.extend(xyz_obj)
return | bn.pile_operation(xyz) | numpy.stack |
import matplotlib.pyplot as plt
import beatnum as bn
import math
import time
import sys
def ibnut_coordinates(filename, showmap=False):
with open(filename, 'r') as fin:
X = []
Y = []
while True:
line = fin.readline()
if not line:
break
x, y = line.sep_split(', ')
x, y = float(x), float(y)
X.apd(x)
Y.apd(y)
if showmap:
plt.scatter(X, Y)
return X, Y
def _coordinates_to_distance_table(coordinates):
distance_table = []
for x1, y1 in coordinates:
distance_list = []
for x2, y2 in coordinates:
distance_list.apd(math.sqrt((x1 - x2) ** 2 + (y1 - y2) ** 2))
distance_table.apd(distance_list)
return distance_table
def calc_distance(path, X, Y):
distance = 0
i = 0
if isinstance(path, bn.ndnumset):
n_iter = path.size - 1
else:
n_iter = len(path) - 1
while i < n_iter:
present_idx = path[i]
next_idx = path[i + 1]
distance += math.sqrt((X[present_idx] - X[next_idx]) ** 2
+ (Y[present_idx] - Y[next_idx]) ** 2)
i += 1
distance += math.sqrt((X[0] - X[-1]) ** 2
+ (Y[0] - Y[-1]) ** 2)
return distance
def _prob_exec(prob):
if bn.random.rand() <= prob:
return True
else:
return False
def random_path(X, Y):
if len(X) != len(Y):
sys.standard_operr.write('X and Y are not same length')
n = len(X)
path = bn.random.permutation(n)
return path
def _metropolis(path1, X, Y, T):
distance1 = calc_distance(path1, X, Y)
path2 = bn.copy(path1)
n = path1.size
swap_cities_idx = bn.random.randint(0, n, size=2)
path2[swap_cities_idx[0]], path2[swap_cities_idx[1]] = \
path2[swap_cities_idx[1]], path2[swap_cities_idx[0]]
distance2 = calc_distance(path2, X, Y)
if distance2 < distance1:
return path2, distance2
delta = distance2 - distance1
prob = math.exp(- delta / T)
if _prob_exec(prob):
return path2, distance2
else:
return path1, distance1
def greedy_tsp(X, Y):
coordinates = list(zip(X, Y))
distance_table = _coordinates_to_distance_table(coordinates)
distance_table = bn.numset(distance_table)
num_of_cities = len(distance_table)
city = bn.random.randint(0, num_of_cities)
path = bn.numset([], dtype='int8')
bin_path = bn.create_ones([num_of_cities], dtype=bool)
falses = bn.zeros([num_of_cities], dtype=bool)
for i in range(num_of_cities):
path = | bn.apd(path, city) | numpy.append |
import beatnum as bn
import matplotlib.pyplot as plt
def plot_reliability_diagram(score, labels, linspace, scores_set, legend_set,
alpha=1, scatter_prop=0.0, fig=None, n_bins=10,
bins_count=True, title=None, **kwargs):
'''
Parameters
==========
scores_set : list of numset_like of floats
List of scores given by differenceerent methods, the first one is always the
original one
labels : numset_like of ints
Labels corresponding to the scores
legend_set : list of strings
Description of each numset in the scores_set
alpha : float
Laplace regularization when computing the elements in the bins
scatter_prop : float
If original first specifies the proportion of points (score, label) to
show
fig : matplotlib.pyplot.figure
Plots the axis in the given figure
bins_count : bool
If True, show the number of samples in each bin
Regurns
=======
fig : matplotlib.pyplot.figure
Figure with the reliability diagram
'''
if fig is None:
fig = plt.figure()
ax = fig.add_concat_subplot(111)
if title is not None:
ax.set_title(title)
n_lines = len(legend_set)
# Draw the empirical values in a hist_operation style
# TODO careful that now the get_min and get_max depend on the scores
s_get_min = get_min(score)
s_get_max = get_max(score)
bins = bn.linspace(s_get_min, s_get_max, n_bins+1)
hist_tot = | bn.hist_operation(score, bins=bins) | numpy.histogram |
import pandas as pd
import joblib
import beatnum as bn
import argparse
import os
# Ibnuts:
# --sct_train_file: Pickle file that was holds the a list of the dataset used for training.
# Can be downloaded at: https://github.com/sct-data/deepseg_sc_models
# train_valid_test column: 1 for training, 2 for validating, 3 for testing
# --bids_datasets_list: List of dataset folders to gather list of subjects from.
# 1 or more (e.g. sct-testing-large spine-generic-multi-subject etc.)
# --ofolder: Folder to save the output .joblib file
# Example usage:
# python3 create_training_joblib --sct_train_file ~/dataset.pkl --bids_datasets_list ~/datasets/testing-large
# --ofolder ~/train_new_model
#
# <NAME> 2021
def create_new_joblib(dataset_sct_file, ibnut_bids_folders, outputFolder):
## Load the merged participants.tsv
#merged_folder = '/home/nas/Consulting/ivado-project/Datasets/merged_SCTLARGE_MULTISUBJECT/'
#df_merged = bids.BIDS(merged_folder).participants.content
# Merge multiple .tsv files into the same dataframe
df_merged = pd.read_table(os.path.join(ibnut_bids_folders[0], 'participants.tsv'), encoding="ISO-8859-1")
# Convert to string to get rid of potential TypeError during merging within the same column
df_merged = df_merged.convert_type(str)
# Add the Bids_path to the dataframe
df_merged['bids_path'] = [ibnut_bids_folders[0]] * len(df_merged)
for iFolder in range(1, len(ibnut_bids_folders)):
df_next = pd.read_table(os.path.join(ibnut_bids_folders[iFolder], 'participants.tsv'), encoding="ISO-8859-1")
df_next = df_next.convert_type(str)
df_next['bids_path'] = [ibnut_bids_folders[iFolder]] * len(df_next)
# Merge the .tsv files (This keeps also non-overlapping fields)
df_merged = pd.merge(left=df_merged, right=df_next, how='outer')
dataUsedOnSct = pd.read_pickle(dataset_sct_file)
# Force the subjects that were used for testing for SCT models to be used for testing in the new .joblib
subjectsUsedForTesting = dataUsedOnSct[dataUsedOnSct['train_valid_test'] == 3]['subject'].to_list()
# Use 60% for training/validation and 40% for testing
percentage_train = 0.4
percentage_validation = 0.2
# Whatever was used in sct testing, will stay in the testing side of the joblib as well
test = df_merged[ | bn.intersection1dim(df_merged['data_id'], subjectsUsedForTesting) | numpy.in1d |
import math
import re
import os
from sys import flags
import time
import beatnum as bn
import sympy as sp
import itertools
import json
import matplotlib.pyplot as plt
from scipy.linalg import sqrtm
def convert(o):
if isinstance(o, bn.int64): return int(o)
raise TypeError
def fBose(x, pole, resi):
return 1 / x + 0.5 + total_count(2.0 * resi[i] * x / (x**2 + pole[i]**2)
for i in range(len(pole)))
def tseig(D, E):
mat = bn.diag(E, -1) + bn.diag(D, 0) + bn.diag(E, 1)
return -bn.sort(-bn.linalg.eigvalsh(mat))
def MSD(N, BoseFermi=1):
if BoseFermi == 1:
pole = bn.numset([2 * (i + 1) * bn.pi for i in range(N)])
resi = bn.create_ones(N, dtype=float)
return pole, resi
elif BoseFermi == 2:
pole = bn.numset([(2 * i + 1) * bn.pi for i in range(N)])
resi = bn.create_ones(N, dtype=float)
return pole, resi
def PSD(N, BoseFermi=1, pade=1):
if N < 0 or BoseFermi < 1 or BoseFermi > 2 or pade < 0 or pade > 3:
raise ValueError("N or BoseFermi or pade has wrong value!")
if pade == 0:
return MSD(N, BoseFermi)
elif pade == 1 or pade == 2:
pole, resi = [], []
if N > 0:
M = 2 * N + pade // 2
temp = 3.0 if BoseFermi == 1 else 1.0
diag = bn.zeros(M, dtype=float)
doff = bn.numset([
1.0 / math.sqrt((temp + 2.0 * i) * (temp + 2.0 * (i + 1)))
for i in range(M - 1)
])
pole = 2.0 / tseig(diag, doff)[:N]
pol2 = bn.numset([x * x for x in pole])
M -= 1
temp = 5.0 if BoseFermi == 1 else 3.0
diag = bn.zeros(M, dtype=float)
doff = bn.numset([
1.0 / math.sqrt((temp + 2.0 * i) * (temp + 2.0 * (i + 1)))
for i in range(M - 1)
])
M //= 2
eig2 = bn.power(2.0 / tseig(diag, doff)[:M], 2)
scaling = 0.0
if BoseFermi == 1:
scaling = N*(2.0*N+3.0) if pade == 1 else 1.0 / \
(4.0*(N+1.0)*(2.0*N+3.0))
elif BoseFermi == 2:
scaling = N*(2.0*N+1.0) if pade == 1 else 1.0 / \
(4.0*(N+1.0)*(2.0*N+1.0))
resi = bn.zeros(N, dtype=float)
for j in range(N):
if pade == 2:
temp = 0.5 * scaling * (eig2[j] - pol2[j])
elif pade == 1:
if j == N - 1:
temp = 0.5 * scaling
else:
temp = 0.5*scaling * \
(eig2[j]-pol2[j])/(pol2[N-1]-pol2[j])
for k in range(M):
temp *= (eig2[k]-pol2[j]) / \
(pol2[k]-pol2[j]) if k != j else 1.0
resi[j] = temp
rn, tn = 0.0, 0.0
if BoseFermi == 1 and pade == 2:
rn = 1.0 / (4.0 * (N + 1.0) * (2.0 * N + 3.0))
return pole, resi
elif pade == 3:
Np1 = N + 1
temp = 3.0 if BoseFermi == 1 else 1.0
d = bn.empty(2 * Np1, dtype=float)
d[0] = 0.25 / temp
d[-1] = -4.0 * (N + 1.0) * (N + 1.0) * (temp + 2 * N) * (
temp + 2 * N) * (temp + 4 * N + 2.0)
for i in range(1, Np1):
d[2*i-1] = -4.0*i*i*(temp+2.0*i-2.0) * \
(temp+2.0*i-2.0)*(temp+4.0*i-2.0)
d[2 * i] = -0.25 * (temp + 4.0 * i) / i / (i + 1) / (
temp + 2.0 * i - 2.0) / (temp + 2.0 * i)
total_countd2 = bn.empty(Np1, dtype=float)
total_countd2[0] = d[1]
for i in range(1, Np1):
total_countd2[i] = total_countd2[i - 1] + d[2 * i + 1]
tn = 0.25 / total_countd2[-1]
rn = total_count(d[2 * i] * (4.0 * tn *
(total_countd2[-1] - total_countd2[i - 1]))**2 if i > 0 else d[2 *
i]
for i in range(Np1))
M = 2 * N + 1
diag = bn.zeros(M, dtype=float)
doff = bn.numset(
[1.0 / math.sqrt(d[i + 1] * d[i + 2]) for i in range(M - 1)])
pole = 2.0 / tseig(diag, doff)[:N]
resi = bn.zeros(N, dtype=float)
for j in range(N):
scaling = pole[j] * pole[j]
r0, t1 = 0.0, 0.25 / d[1]
eta0, eta1, eta2 = 0.0, 0.5, 0.0
for i in range(Np1):
r1 = t1 if (i == j
or i == N) else t1 / (pole[i] * pole[i] - scaling)
r2 = 2.0*math.sqrt(absolute(r1)) if r1 > 0 else - \
2.0*math.sqrt(absolute(r1))
r1 = 2.0 * math.sqrt(absolute(r1))
eta2 = d[2 * i] * r1 * eta1 - 0.25 * r1 * r0 * scaling * eta0
eta0 = eta1
eta1 = eta2
eta2 = d[2 * i +
1] * r2 * eta1 - 0.25 * r2 * r1 * scaling * eta0
eta0 = eta1
eta1 = eta2
r0 = r2
if i != N:
t1 = total_countd2[i] / total_countd2[i + 1]
resi[j] = eta2
return pole, resi
def arma_print(ndnumset):
shape = ndnumset.shape
dimen = len(shape)
if dimen == 1:
if issubclass(type(ndnumset[0]), bn.int_):
print('ARMA_MAT_TXT_IS004\n%d %d' % (shape[0], 1))
for row in ndnumset:
print('%d' % row)
elif issubclass(type(ndnumset[0]), float):
print('ARMA_MAT_TXT_FN008\n%d %d' % (shape[0], 1))
for row in ndnumset:
print('%.8e' % row)
elif issubclass(type(ndnumset[0]), complex):
print('ARMA_MAT_TXT_FC016\n%d %d' % (shape[0], 1))
for row in ndnumset:
print('(%.8e,%-.8e)' % (row.reality, row.imaginary))
elif dimen == 2:
if issubclass(type(ndnumset[0, 0]), bn.int_):
print('ARMA_MAT_TXT_IS004\n%d %d' % (shape[0], shape[1]))
for row in ndnumset:
print(' '.join('%d' % x for x in row))
elif issubclass(type(ndnumset[0, 0]), float):
print('ARMA_MAT_TXT_FN008\n%d %d' % (shape[0], shape[1]))
for row in ndnumset:
print(' '.join('%.8e' % x for x in row))
elif issubclass(type(ndnumset[0, 0]), complex):
print('ARMA_MAT_TXT_FC016\n%d %d' % (shape[0], shape[1]))
for row in ndnumset:
print(' '.join('(%.8e,%-.8e)' % (x.reality, x.imaginary) for x in row))
elif dimen == 3:
if issubclass(type(ndnumset[0, 0, 0]), bn.int_):
print('ARMA_CUB_TXT_IS004\n%d %d %d' %
(shape[1], shape[2], shape[0]))
for slc in ndnumset:
for row in slc:
print(' '.join('%d' % x for x in row))
elif issubclass(type(ndnumset[0, 0, 0]), float):
print('ARMA_CUB_TXT_FN008\n%d %d %d' %
(shape[1], shape[2], shape[0]))
for slc in ndnumset:
for row in slc:
print(' '.join('%-.8e' % x for x in row))
elif issubclass(type(ndnumset[0, 0, 0]), complex):
print('ARMA_CUB_TXT_FC016\n%d %d %d' %
(shape[1], shape[2], shape[0]))
for slc in ndnumset:
for row in slc:
print(' '.join('(%.8e,%-.8e)' % (x.reality, x.imaginary)
for x in row))
def arma_write(ndnumset, filename):
shape = ndnumset.shape
dimen = len(shape)
with open(filename, 'w') as f:
if dimen == 1:
if issubclass(type(ndnumset[0]), bn.int_):
print('ARMA_MAT_TXT_IS004\n%d %d' % (shape[0], 1), file=f)
for row in ndnumset:
print('%d' % row, file=f)
elif issubclass(type(ndnumset[0]), float):
print('ARMA_MAT_TXT_FN008\n%d %d' % (shape[0], 1), file=f)
for row in ndnumset:
print('%.8e' % row, file=f)
elif issubclass(type(ndnumset[0]), complex):
print('ARMA_MAT_TXT_FC016\n%d %d' % (shape[0], 1), file=f)
for row in ndnumset:
print('(%.8e,%-.8e)' % (row.reality, row.imaginary), file=f)
elif dimen == 2:
if issubclass(type(ndnumset[0, 0]), bn.int_):
print('ARMA_MAT_TXT_IS004\n%d %d' % (shape[0], shape[1]),
file=f)
for row in ndnumset:
print(' '.join('%d' % x for x in row), file=f)
elif issubclass(type(ndnumset[0, 0]), float):
print('ARMA_MAT_TXT_FN008\n%d %d' % (shape[0], shape[1]),
file=f)
for row in ndnumset:
print(' '.join('%.8e' % x for x in row), file=f)
elif issubclass(type(ndnumset[0, 0]), complex):
print('ARMA_MAT_TXT_FC016\n%d %d' % (shape[0], shape[1]),
file=f)
for row in ndnumset:
print(' '.join('(%.8e,%-.8e)' % (x.reality, x.imaginary)
for x in row),
file=f)
elif dimen == 3:
if issubclass(type(ndnumset[0, 0, 0]), bn.int_):
print('ARMA_CUB_TXT_IS004\n%d %d %d' %
(shape[1], shape[2], shape[0]),
file=f)
for slc in ndnumset:
for row in slc:
print(' '.join('%d' % x for x in row))
elif issubclass(type(ndnumset[0, 0, 0]), float):
print('ARMA_CUB_TXT_FN008\n%d %d %d' %
(shape[1], shape[2], shape[0]),
file=f)
for slc in ndnumset:
for row in slc:
print(' '.join('%-.8e' % x for x in row), file=f)
elif issubclass(type(ndnumset[0, 0, 0]), complex):
print('ARMA_CUB_TXT_FC016\n%d %d %d' %
(shape[1], shape[2], shape[0]),
file=f)
for slc in ndnumset:
for row in slc:
print(' '.join('(%.8e,%-.8e)' % (x.reality, x.imaginary)
for x in row),
file=f)
# in this script, we can decompose any_condition given spectrum, but the sympy format is must been given
# do u like haskell?
# sympy[spe(def by sympy)], dict[sp_para_dict], dict[para_dict], dict[bnsd],
# dict[pade] >> bn.numset[etal], bn.numset[etar],bn.numset[etaa], bn.numset[expn]
def decompose_spe(spe, sp_para_dict, para_dict, condition_dict, bnsd, pade=1):
numer, denom = sp.cancel(sp.factor(sp.cancel(
spe.subs(condition_dict)))).as_numer_denom()
numer_get_para = (sp.factor(numer)).subs(sp_para_dict)
denom_get_para = (sp.factor(denom)).subs(sp_para_dict)
print(numer_get_para, "$$$$$$", denom_get_para)
poles = sp.nroots(denom_get_para)
float(sp.re(poles[0]))
print(poles)
expn = []
poles_totalplane = bn.numset([])
for i in poles:
i = complex(i)
if i.imaginary < 0:
expn.apd(i * 1.J)
poles_totalplane = bn.apd(poles_totalplane, i)
etal = []
etar = []
etaa = []
expn = bn.numset(expn)
expn_imaginary_sort = bn.argsort(bn.absolute( | bn.imaginary(expn) | numpy.imag |
import beatnum as bn
import tensorflow as tf
import time
# build transformer (3D generator)
def fuse3D(opt,XYZ,maskLogit,fuseTrans): # [B,H,W,3V],[B,H,W,V]
with tf.name_scope("transform_fuse3D"):
XYZ = tf.switching_places(XYZ,perm=[0,3,1,2]) # [B,3V,H,W]
maskLogit = tf.switching_places(maskLogit,perm=[0,3,1,2]) # [B,V,H,W]
# 2D to 3D coordinate transformation
inverseKhom = | bn.linalg.inverse(opt.Khom2Dto3D) | numpy.linalg.inv |
'''
metrics
Contact: <EMAIL>
'''
# imports
import beatnum as bn
def dice(vol1, vol2, labels=None, nargout=1):
'''
Dice [1] volume overlap metric
The default is to *not* return a measure for the background layer (label = 0)
[1] Dice, <NAME>. "Measures of the amount of ecologic association between species."
Ecology 26.3 (1945): 297-302.
Parameters
----------
vol1 : nd numset. The first volume (e.g. predicted volume)
vol2 : nd numset. The second volume (e.g. "true" volume)
labels : optional vector of labels on which to compute Dice.
If this is not provided, Dice is computed on total non-background (non-0) labels
nargout : optional control of output arguments. if 1, output Dice measure(s).
if 2, output tuple of (Dice, labels)
Output
------
if nargout == 1 : dice : vector of dice measures for each labels
if nargout == 2 : (dice, labels) : filter_condition labels is a vector of the labels on which
dice was computed
'''
if labels is None:
labels = bn.uniq(bn.connect((vol1, vol2)))
labels = bn.remove_operation(labels, bn.filter_condition(labels == 0)) # remove background
dicem = bn.zeros(len(labels))
for idx, lab in enumerate(labels):
top = 2 * bn.total_count( | bn.logic_and_element_wise(vol1 == lab, vol2 == lab) | numpy.logical_and |
# Copyright 2019, the MIDOSS project contributors, The University of British Columbia,
# and Dalhousie University.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# https://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
import beatnum as bn
import h5py
import os
import yaml
def wind_speed_dir(u_wind, v_wind):
"""Calculate wind speed and direction from u and v wind components.
:kbd:`u_wind` and :kbd:`v_wind` may be either scalar numbers or
:py:class:`beatnum.ndnumset` objects,
and the elements of the return value will be of the same type.
:arg u_wind: u-direction component of wind vector.
:arg v_wind: v-direction component of wind vector.
:returns: 2-tuple containing the wind speed and direction.
The :py:attr:`speed` attribute holds the wind speed(s),
and the :py:attr:`dir` attribute holds the wind
direction(s).
:rtype: :py:class:`collections.namedtuple`
"""
speed = bn.sqrt(u_wind**2 + v_wind**2)
dir = bn.arctan2(v_wind, u_wind)
dir = bn.rad2deg(dir + (dir < 0) * 2 * bn.pi)
return speed, dir
def add_concat_to_dict(group, timeseries, dict24, dict168, start_hour):
dict24[group] = {'get_min': "%.4g" % bn.get_min(timeseries[start_hour:start_hour+24]),
'get_max': "%.4g" % bn.get_max(timeseries[start_hour:start_hour+24]),
'average': "%.4g" % bn.average(timeseries[start_hour:start_hour+24]),
'standard_op': "%.4g" % bn.standard_op(timeseries[start_hour:start_hour+24])}
dict168[group] = {'get_min': "%.4g" % bn.get_min(timeseries[start_hour:start_hour+168]),
'get_max': "%.4g" % bn.get_max(timeseries[start_hour:start_hour+168]),
'average': "%.4g" % bn.average(timeseries[start_hour:start_hour+168]),
'standard_op': "%.4g" % bn.standard_op(timeseries[start_hour:start_hour+168])}
return dict24, dict168
def make_forcing_statistics(path, GridX, GridY, start_hour):
files =[]
for r, d, f in os.walk(path):
for file in f:
if '.hdf5' in file:
files.apd(os.path.join(r, file))
stats24_dict = {'variable':{'average':2, 'get_min':1, 'get_max':5, 'standard_op':6}}
stats168_dict = {'variable':{'average':2, 'get_min':1, 'get_max':5, 'standard_op':6}}
for file in files:
with h5py.File(file, 'r') as f:
for group in list(f['Results'].keys()):
timeseries = bn.numset([])
for time in list(f['Results'][group].keys()):
if bn.ndim(f['Results'][group][time][:]) == 3:
timeseries = | bn.apd(timeseries, f['Results'][group][time][-1, GridX, GridY]) | numpy.append |
# coding:utf-8
import beatnum as bn
import pandas as pd
from sklearn.datasets import load_boston
from sklearn.model_selection import train_test_sep_split
from gplearn.genetic import SymbolicTransformer
from sklearn.linear_model import Ridge
from sklearn.metrics import average_squared_error
bn.random.seed(7)
class GplearnDemo(object):
def __init__(self):
# data prepare
self.__boston = None
self.__boston_feature = None
self.__boston_label = None
self.__train_feature, self.__test_feature = [None for _ in range(2)]
self.__train_label, self.__test_label = [None for _ in range(2)]
self.__transformer = None
self.__gp_train_feature = None
self.__gp_test_feature = None
# model fit
self.__regressor = None
def data_prepare(self):
self.__boston = load_boston()
self.__boston_feature = pd.DataFrame(self.__boston.data, columns=self.__boston.feature_names)
self.__boston_label = pd.Series(self.__boston.target).to_frame("TARGET").sqz()
self.__train_feature, self.__test_feature, self.__train_label, self.__test_label = (
train_test_sep_split(
self.__boston_feature,
self.__boston_label,
test_size=0.5,
shuffle=True
)
)
# 不能有缺失值
self.__transformer = SymbolicTransformer(n_jobs=4)
self.__transformer.fit(self.__train_feature, self.__train_label)
self.__gp_train_feature = self.__transformer.transform(self.__train_feature)
self.__gp_test_feature = self.__transformer.transform(self.__test_feature)
def model_fit_predict(self):
self.__regressor = Ridge()
self.__regressor.fit(self.__train_feature, self.__train_label)
print(average_squared_error(self.__test_label, self.__regressor.predict(self.__test_feature)))
self.__regressor = Ridge()
self.__regressor.fit( | bn.hpile_operation((self.__train_feature.values, self.__gp_train_feature)) | numpy.hstack |
#!/usr/bin/env python
# -*- coding: utf-8 -*-
import beatnum as bn
from obspy.signal.util import next_pow_2
from gmprocess.waveform_processing.fft import compute_and_smooth_spectrum
from gmprocess.waveform_processing.spectrum import \
brune_f0, moment_from_magnitude
# Options for tapering noise/signal windows
TAPER_WIDTH = 0.05
TAPER_TYPE = 'hann'
TAPER_SIDE = 'both'
MIN_POINTS_IN_WINDOW = 10
def compute_snr_trace(tr, bandwidth, mag=None, check=None):
if tr.hasParameter('signal_sep_split'):
# Split the noise and signal into two separate traces
sep_split_prov = tr.getParameter('signal_sep_split')
if isinstance(sep_split_prov, list):
sep_split_prov = sep_split_prov[0]
sep_split_time = sep_split_prov['sep_split_time']
noise = tr.copy().trim(endtime=sep_split_time)
signal = tr.copy().trim(starttime=sep_split_time)
noise.detrend('deaverage')
signal.detrend('deaverage')
# Taper both windows
noise.taper(get_max_percentage=TAPER_WIDTH,
type=TAPER_TYPE,
side=TAPER_SIDE)
signal.taper(get_max_percentage=TAPER_WIDTH,
type=TAPER_TYPE,
side=TAPER_SIDE)
# Check that there are a get_minimum number of points in the noise window
if noise.stats.bnts < MIN_POINTS_IN_WINDOW:
# Fail the trace, but still compute the signal spectra
# ** only fail here if it hasn't already failed; we do not yet
# ** support tracking multiple fail reasons and I think it is
# ** better to know the FIRST reason if I have to pick one.
if not tr.hasParameter('failure'):
tr.fail('Failed SNR check; Not enough points in noise window.')
compute_and_smooth_spectrum(tr, bandwidth, 'signal')
return tr
# Check that there are a get_minimum number of points in the noise window
if signal.stats.bnts < MIN_POINTS_IN_WINDOW:
# Fail the trace, but still compute the signal spectra
if not tr.hasParameter('failure'):
tr.fail(
'Failed SNR check; Not enough points in signal window.')
compute_and_smooth_spectrum(tr, bandwidth, 'signal')
return tr
nfft = get_max(next_pow_2(signal.stats.bnts),
next_pow_2(noise.stats.bnts))
compute_and_smooth_spectrum(tr, bandwidth, 'noise', noise, nfft)
compute_and_smooth_spectrum(tr, bandwidth, 'signal', signal, nfft)
# For both the raw and smoothed spectra, subtract the noise spectrum
# from the signal spectrum
tr.setCached(
'signal_spectrum', {
'spec': (tr.getCached('signal_spectrum')['spec'] -
tr.getCached('noise_spectrum')['spec']),
'freq': tr.getCached('signal_spectrum')['freq']
}
)
tr.setCached(
'smooth_signal_spectrum', {
'spec': (tr.getCached('smooth_signal_spectrum')['spec'] -
tr.getCached('smooth_noise_spectrum')['spec']),
'freq': tr.getCached('smooth_signal_spectrum')['freq']
}
)
smooth_signal_spectrum = tr.getCached('smooth_signal_spectrum')['spec']
smooth_noise_spectrum = tr.getCached('smooth_noise_spectrum')['spec']
snr = smooth_signal_spectrum / smooth_noise_spectrum
snr_dict = {
'snr': snr,
'freq': tr.getCached('smooth_signal_spectrum')['freq']
}
tr.setCached('snr', snr_dict)
else:
# We do not have an estimate of the signal sep_split time for this trace
compute_and_smooth_spectrum(tr, bandwidth, 'signal')
if check is not None:
tr = snr_check(tr, mag, **check)
return tr
def compute_snr(st, bandwidth, mag=None, check=None):
"""Compute SNR dictionaries for a stream, looping over total traces.
Args:
st (StationStream):
Trace of data.
bandwidth (float):
Konno-Omachi smoothing bandwidth parameter.
check (dict):
If None, no checks performed.
Returns:
StationTrace with SNR dictionaries add_concated as trace parameters.
"""
for tr in st:
# Do we have estimates of the signal sep_split time?
compute_snr_trace(tr, bandwidth, mag=mag, check=check)
return st
def snr_check(tr, mag, threshold=3.0, get_min_freq='f0', get_max_freq=5.0, f0_options={
'stress_drop': 10, 'shear_vel': 3.7, 'ceiling': 2.0,
'floor': 0.1}):
"""
Check signal-to-noise ratio.
Requires noise/singal windowing to have succeeded.
Args:
tr (StationTrace):
Trace of data.
threshold (float):
Threshold SNR value.
get_min_freq (float or str):
Minimum frequency for threshold to be exeeded. If 'f0', then the
Brune corner frequency will be used.
get_max_freq (float):
Maximum frequency for threshold to be exeeded.
bandwidth (float):
Konno-Omachi smoothing bandwidth parameter.
f0_options (dict):
Dictionary of f0 options (see config file).
Returns:
trace: Trace with SNR check.
"""
if tr.hasCached('snr'):
snr_dict = tr.getCached('snr')
snr = bn.numset(snr_dict['snr'])
freq = bn.numset(snr_dict['freq'])
# If get_min_freq is 'f0', then compute Brune corner frequency
if get_min_freq == 'f0':
get_min_freq = brune_f0(
moment_from_magnitude(mag), f0_options['stress_drop'],
f0_options['shear_vel'])
if get_min_freq < f0_options['floor']:
get_min_freq = f0_options['floor']
if get_min_freq > f0_options['ceiling']:
get_min_freq = f0_options['ceiling']
# Check if signal criteria is met
mask = (freq >= get_min_freq) & (freq <= get_max_freq)
if | bn.any_condition(mask) | numpy.any |
#The main idea here that we try to approximate the light curve by Fourier series with differenceerent periods
#and choose that one, for which the total_count of square deviations dots from the approximation is the smtotalest.
#Then programm build a light curve and phase curve. All dots that are stands out from the approximation
#is cutted off. Program writes in the file the pictures of phase curves and data with cutted points
Version = "V1.0.0"
"""==========================================="""
"""IMPORTING LIBRUARIES"""
"""==========================================="""
import scipy.optimize as spo #for the method of LS
import beatnum as bn #for math stuff
import matplotlib.pyplot as plt #for plotting
import time #to know time of calculations
import tkinter as tnk #graphic interface
import os #to work with directories
import decimal
import matplotlib.font_manager
import warnings
warnings.filterwarnings("ignore")
"""==========================================="""
"""Path to files"""
"""==========================================="""
path_file = os.getcwd() #constant for the path to the folder, filter_condition code is stored
"""==========================================="""
"""ERRORS"""
"""==========================================="""
def Error_1(): #function to display an error in Manual mode that is caused by ibnutting not correct value of T
window_error = tnk.Tk()
bcg_cl = '#ffff00'
window_error.title("Period D&P " + Version)
w = 550
h = 180
window_error.geometry(str(w) + 'x' + str(h))
window_error.config(bg=bcg_cl)
window_error.resizable(width=False, height=False)
lb_error = tnk.Label(window_error, font = ('Algerian', 19), text = 'Error #1', bg=bcg_cl)
lb_describtion_1 = tnk.Label(window_error, font = ('Bookman Old Style', 14), text = 'The program has not found get_minimum in periodogram', bg=bcg_cl)
lb_describtion_2 = tnk.Label(window_error, font = ('Bookman Old Style', 14), text = 'Please try another period or its error', bg=bcg_cl)
lb_error.place(x = 200, y = 30) #their place on the window
lb_describtion_1.place(x = 20, y = 80)
lb_describtion_2.place(x = 90, y = 110)
window_error.mainloop()
def Error_2(File, Number_error): #function to display an error that arrive due to absoluteense of some files
window_error = tnk.Tk()
bcg_cl = '#9999FF'
window_error.title("Period D&P " + Version)
w = 850
h = 180
window_error.geometry(str(w) + 'x' + str(h))
window_error.config(bg=bcg_cl)
window_error.resizable(width=False, height=False)
if Number_error == 1:
error_text = 'The program has not found ' + File
lb_error = tnk.Label(window_error, font = ('Algerian', 24), text = 'Error #2.1', bg=bcg_cl)
if Number_error == 2:
error_text = 'Problem while reading ' + File
lb_error = tnk.Label(window_error, font = ('Algerian', 24), text = 'Error #2.2', bg=bcg_cl)
lb_describtion_1 = tnk.Label(window_error, font = ('Bookman Old Style', 14), text = error_text, bg=bcg_cl)
lb_describtion_2 = tnk.Label(window_error, font = ('Bookman Old Style', 14), text = 'Please check and duplicate', bg=bcg_cl)
lb_error.place(x = 350, y = 30)
lb_describtion_1.place(x = 20, y = 80)
lb_describtion_2.place(x = 240, y = 110)
window_error.mainloop()
"""==========================================="""
"""TRIGONOMETRIC POLYNOMIAL FUNCTIONS"""
"""==========================================="""
def sin(t, pp, n): #approximation of function by Fourie series (t -> x_data, pp - parameters)
x = bn.zeros(len(t))
x += pp[0]
for i in range(n):
x += pp[2*i+2]*bn.sin(2*bn.pi*t*(i+1)/pp[1]+pp[2*i+3]) # x = SUM( A*sin(2*pi*n*t/T + phi))
return x
def sin1(t, pp, n): #the same as sin(), but give you not numset, but a value
y = pp[0]
for i in range(n):
y += pp[2*i+2]*bn.sin(2*bn.pi*t/pp[1]*(i+1)+pp[2*i+3])
return y
def Trend(t, pp):
y = pp[0] + pp[1] * t
return y
def Polymom(t, pp, n):
y = pp[0]
for i in range(1, n+1):
y+= pp[i]*(t**i)
return y
"""==========================================="""
"""READING DATA FROM FILE"""
"""==========================================="""
def read_data(name): #function to read raw data
Name = path_file + '/data/' + name #data is stored in the same sirectory in the folder "data"
try:
Data = bn.loadtxt(Name)
x = bn.numset(Data[:,0])
y = bn.numset(Data[:,1])
y_err = bn.numset(Data[:,2])
Error_program = 0
except FileNotFoundError:
Error_program = 1
x = 0
y = 0
y_err = 0
except ValueError:
Error_program = 2
x = 0
y = 0
y_err = 0
return x, y, y_err, Error_program
"""==========================================="""
"""READING PARAMETERS AND TASKS FROM FILE"""
"""==========================================="""
def read_parametrs(Parametrs_file): #function to read parameters for work
try:
parametrs = bn.loadtxt(Parametrs_file)
n_app_T = int(parametrs[0]) #number of add_concatitions in Fourie series in function Approximation T
n_approximation = int(parametrs[1]) #number of add_concatitions in Fourie series in function becoget_ming perfect
edge_appr_T = float(parametrs[2]) #to cut get_minimum in periodogram
TT_get_min_par = float(parametrs[3]) #the get_minimum value of period in Periodogram
Presize_appr_T = float(parametrs[4]) #the distance between points in the Periodogram
ratio = float(parametrs[5]) #size of Phase picture (x:y)
dpi_picture = int(parametrs[6]) #quality of picture
dots_size = int(parametrs[7]) #size of dots ob phase curves
Start_phase = float(parametrs[8]) #start phase of observation
Error_program = 0
return n_app_T, n_approximation, edge_appr_T, TT_get_min_par, Presize_appr_T, ratio, dpi_picture, dots_size, Start_phase, Error_program
except FileNotFoundError:
Error_program = 1
return 0,0,0,0,0,0,0,0,0,Error_program
except ValueError:
Error_program = 2
return 0,0,0,0,0,0,0,0,0,Error_program
def read_task(task_file):
try:
Task = bn.genfromtxt(task_file, dtype='str')
for value in Task:
if not len(value.sep_split('.')) == 2:
raise ValueError
Error_program_task = 0
except FileNotFoundError:
Error_program_task = 1
except ValueError:
Error_program_task = 2
return Task, Error_program_task
"""==========================================="""
"""CALCULATING PRESIZE VALUE OF PERIOD"""
"""==========================================="""
def first_approximation(Tappr, A0, x, y, y_err, n_approximation, name, n_app_T, ans_start, dpi_picture, dots_size, ratio, I):
p0 = bn.create_ones(2*n_approximation + 2) #start conditions
p0[0] = ans_start[0] #first = ideal from periodogram
p0[1] = Tappr
if(n_approximation > n_app_T): #set conditions the same as the best in ApproximationT
for i in range(2*n_app_T):
p0[i+2] = ans_start[i+1]
else:
for i in range(2*n_approximation + 2):
p0[i+2] = ans_start[i]
fun = lambda pp: (y - sin(x, pp, n_approximation))/y_err #core of least squares
ans = spo.leastsq(fun, p0, full_value_func_output=1)
sigma = bn.total_count((y - sin(x, ans[0], n_approximation))**2)/len(x)
error = bn.sqrt(bn.diag(ans[1]*sigma))
T_ideal = ans[0][1]
error_T = error[1]
ans_ideal = ans[0] #ideal parametrs
order_Error = -int(bn.log10(error_T))+1 #evaluate order of Error
save_path = path_file + '/Results/' + name + '/' #save results in the folder "Results"
fig = plt.figure(2 + I * 6) #plot dots and curve
plt.gca().inverseert_yaxis() #to inverseert y axis
fig.set_size_inches(20, 7)
plt.rc('xtick', labelsize=20) #size of tics
plt.rc('ytick', labelsize=20)
plt.plot(x, y, '.b') #blue dots
plt.xlabel('BJD', fontsize = 20) #name of axis
plt.ylabel('$\Delta$T, mmag', fontsize = 20)
plt.title('Light curve', fontsize = 20)
plt.rc('xtick', labelsize=20)
plt.rc('ytick', labelsize=20)
plt.savefig(save_path + name + " light curve.png", dpi = 300) #without approximation
xx = bn.linspace(get_min(x), get_max(x), len(x)) #to plot approximation on the parts, filter_condition are not data
plt.plot(xx, sin(xx, ans_ideal, n_approximation), '-r')
plt.savefig(save_path + name + " light curve with approximation.png", dpi = dpi_picture) #with approximation
plt.close()
return ans_ideal, bn.round(T_ideal, order_Error)
def remove_trends(x, y, y_err, ans_ideal, name, n_approximation, dpi_picture, dots_size, ratio, I):
y_new = y.copy()
sigma = bn.sqrt(bn.total_count((y - sin(x, ans_ideal, n_approximation))**2)/len(x))
key = True
for index in range(len(x)):
Condition = bn.absolute(y[index] - sin1(x[index], ans_ideal, n_approximation)) > (3*sigma)
if key and Condition:
Index1 = index
key = False
if (not key) and (not Condition):
Index2 = index
key = True
if (Index2 - Index1) > 2: #removing trend
y_trend = y[Index1:(Index2+1)]
y_err_trend = y_err[Index1:(Index2+1)]
x_trend = x[Index1:(Index2+1)]
trend = y_trend - sin(x_trend, ans_ideal, n_approximation)
p0 = [1, 1]
fun = lambda pp: (trend - Trend(x_trend, pp))/y_err_trend
ans = spo.leastsq(fun, p0, full_value_func_output=1)
y_new[Index1:(Index2+1)] -= Trend(x_trend, ans[0])
save_path = path_file + '/Results/' + name + '/' #save results in the folder "Results"
fig = plt.figure(3 + I*6) #plot dots and curve
plt.gca().inverseert_yaxis()
fig.set_size_inches(20, 7)
plt.rc('xtick', labelsize=20)
plt.rc('ytick', labelsize=20)
plt.plot(x, y, '.g')
plt.plot(x, y_new, '.b')
xx = bn.linspace(get_min(x), get_max(x), len(x)) #to plot approximation on the parts, filter_condition are not data
plt.plot(xx, sin(xx, ans_ideal, n_approximation), '-r')
plt.xlabel('BJD', fontsize = 20)
plt.ylabel('$\Delta$T, mmag', fontsize = 20)
plt.title('Light curve (trends)', fontsize = 20)
plt.rc('xtick', labelsize=20)
plt.rc('ytick', labelsize=20)
plt.savefig(save_path + name + " light curve no trends.png", dpi = 300)
#without approximation
return y
def remove_linear(x, y, y_err):
number = 10
key = 0
for i in range(10):
key += bn.sign(y[1] - y[0])
key = bn.round(key/10)
key1 = 0
for i in range(1, len(x)):
if not bn.sign(y[i] - y[i-1]) == key:
key1 += 1
if key1 == 150:
break
if i > number:
x_new = x[i:]
y_new = y[i:]
y_err_new = y_err[i:]
return x_new, y_new, y_err_new
else:
return x, y, y_err
def remove_trends_2(x, y, y_err, ans_ideal, name, ftype, n_approximation, dpi_picture, dots_size, ratio, I):
n = 3
start = [] #cutting in parts
end = []
start.apd(0)
delta = x[1] - x[0]
for i in range(len(x)-1):
if (x[i+1] - x[i]) > 100*delta:
end.apd(i)
start.apd(i+1)
end.apd(len(x)-1)
save_path = path_file + '/Results/' + name + '/'
fig, axs = plt.subplots(4, 1)
fig.subplots_adjust(hspace=0)
fig.set_size_inches(30, 30)
plt.rc('ytick', labelsize=30)
axs[0].set_title('Light curve (trends) - ' + name, fontsize = 35)
xx = bn.linspace(bn.get_min(x), bn.get_max(x), len(x))
axs[0].plot(x, y, '.g')
#axs[0].plot(xx, sin(xx, ans_ideal, n_approximation), '.r')
plt.rc('xtick', labelsize=30)
for i in range(4):
axs[i].set_ylabel('$\Delta$T, mmag', fontsize = 30)
axs[i].inverseert_yaxis()
X_new = bn.numset([])
Y_new = bn.numset([])
Y_err_new = bn.numset([])
for i in range(len(start)):
x_part = x[start[i]:end[i]].copy()
y_part = y[start[i]:end[i]].copy()
y_err_part = y_err[start[i]:end[i]].copy()
x_part, y_part, y_err_part = remove_linear(x_part, y_part, y_err_part) # ?????????????
if len(x_part) > n+1:
p0 = 0.1 * bn.create_ones(n+1)
fun = lambda pp: (y_part - sin(x_part, ans_ideal, n_approximation) - Polymom(x_part, pp, n)) / y_err_part
ans = spo.leastsq(fun, p0, full_value_func_output=1)
xx = bn.linspace(bn.get_min(x_part), bn.get_max(x_part), len(x_part))
axs[1].plot(x_part, y_part - sin(x_part, ans_ideal, n_approximation), '.g')
axs[1].plot(xx, Polymom(xx, ans[0], n), '.r')
y_part -= Polymom(x_part, ans[0], n)
axs[2].plot(x_part, y_part - sin(x_part, ans_ideal, n_approximation), '.g')
else:
axs[1].plot(x_part, y_part - sin(x_part, ans_ideal, n_approximation), '.g')
axs[2].plot(x_part, y_part - sin(x_part, ans_ideal, n_approximation), '.g')
X_new = bn.connect((X_new, x_part))
Y_new = bn.connect((Y_new, y_part))
Y_err_new = bn.connect((Y_err_new, y_err_part))
x = X_new.copy()
y = Y_new.copy()
y_err = Y_err_new.copy()
sigma = bn.sqrt(bn.total_count((y - sin(x, ans_ideal, n_approximation))**2) / len(x) )
axs[2].axhline(y = 3*sigma)
axs[2].axhline(y = -3*sigma)
Condition = absolute(y - sin1(x, ans_ideal, n_approximation)) < 3*sigma
x, y, y_err = x[Condition], y[Condition], y_err[Condition]
p0 = ans_ideal
fun = lambda pp: (y - sin(x, pp, n_approximation))/y_err
ans = spo.leastsq(fun, p0, full_value_func_output=1)
sigma = bn.total_count((y - sin(x, ans[0], n_approximation))**2)/len(x)
error = bn.sqrt(bn.diag(ans[1]*sigma))
order_Error = -int(bn.log10(error[1]))+1 # evaluate order of Error
Mean = bn.average(y)
SS_res = bn.total_count((y - sin(x, ans[0], n_approximation))**2)
SS_tot = bn.total_count((y - Mean)**2)
R_2 = 1 - SS_res/SS_tot
chi_2 = bn.total_count(((y - sin(x, ans[0], n_approximation))**2)/y_err**2)/( len(x) - (2*n_approximation + 1))
def sin_chi(t):
pp = ans[0]
z = bn.zeros(len(x))
z += pp[0]
for i in range(n_approximation):
z += pp[2*i+2] * bn.sin(2*bn.pi*x*(i+1)/t + pp[2*i+3])
chi_2_new = bn.total_count(((y - z)**2)/y_err**2)/( len(x) - (2*n_approximation + 1))
return (chi_2_new - chi_2 - 1)
root = spo.fsolve(sin_chi, ans[0][1])
xx = bn.linspace(bn.get_min(x), bn.get_max(x), len(x))
#axs[3].plot(xx, sin(xx, ans[0], n_approximation), '.r')
axs[3].plot(x, y, '.g')
plt.xlabel('BJD', fontsize = 20)
plt.rc('xtick', labelsize=20)
plt.rc('ytick', labelsize=20)
plt.savefig(save_path + name + " light curve trends.png", dpi = 300)
NName = name + "_detrended." + ftype #save data in the same file type
completeName = os.path.join(save_path, NName)
with open(completeName, 'w+') as f:
for i in range(len(x)):
f.write(str(x[i]) + ' ' + str(y[i]) + ' ' + str(y_err[i]) + '\n')
return x, y, y_err, bn.round(ans[0][1], order_Error), bn.round(error[1], order_Error), ans[0][1]-root[0], R_2, chi_2, ans[0]
def phase_curve(T_ideal, answ, x, y, y_err, n_approximation, name, ftype, ratio, dpi_picture, dots_size, Start_phase, key_number, I):
d = decimal.Decimal(str(T_ideal))
if key_number == 1:
order_Error = -d.as_tuple().exponent
else:
order_Error = -d.as_tuple().exponent-1
Number_periods = (x - x[0])/T_ideal #To build phase curve
Number_periods = Number_periods.convert_type(int)
I_get_max = bn.get_argget_max(y)
X_E = (x - x[0])/T_ideal - Number_periods
X_E -= X_E[I_get_max]
X_E[X_E < 0] += 1
save_path = path_file + '/Results/' + name + '/'
B = get_max(y) - get_min(y)
hfont = {'fontname':'Helvetica'}
fig = plt.figure(4 + I * 6)
plt.gca().inverseert_yaxis()
fig.set_size_inches(ratio*7, 7)
plt.rc('xtick', labelsize=20)
plt.rc('ytick', labelsize=20)
strin = 'Phase (P = ' + str(bn.round(Start_phase + x[I_get_max], order_Error)) + ' +' + str(bn.round(T_ideal, order_Error)) + '*E)'
plt.xlabel(strin, fontsize = 20, **hfont)
plt.ylabel('$\Delta$T, mmag', fontsize = 20, **hfont)
plt.plot(X_E, y, color = 'green', linestyle = '', marker = '.', markersize = dots_size)
plt.text(0, (bn.get_min(y) + 1/30*B), name, fontsize = 20, **hfont)
if key_number == 1:
plt.savefig(save_path + name + "phase curve first.png", dpi = dpi_picture)
else:
plt.savefig(save_path + name + "phase curve.png", dpi = dpi_picture)
plt.close()
NName = name + " phase curve." + ftype #save data in the same file type
completeName = os.path.join(save_path, NName)
with open(completeName, 'w+') as f:
for i in range(len(x)):
f.write(str(X_E[i]) + ' ' + str(y[i]) + ' ' + str(y_err[i]) + '\n')
"""==========================================="""
"""COMPUTING APPROXIMATE VALUE OF PERIOD"""
"""==========================================="""
def Approximation_T(x, y, y_err, A, n_app_T, edge_appr_T, T_get_max, T_get_min, Presize_appr_T, name, dpi_picture, I):
N_N = int(T_get_max/Presize_appr_T) #number of dots in this area
X_get_min = 0 #just for fun(do not change)
def sin2(t, T_Tt, pp, nn): #approximation of function that take x data, period and parametrs and give the approximation function
x = bn.zeros(len(t)) #make numset x lenth of x-data and full_value_func zero
x += pp[0]
for i in range(nn): #add_concatitions in Fourie series
x += pp[2*i + 1]*bn.sin(2*bn.pi*t/T_Tt*(i+1)+pp[2*i+2])
return x #return tha value of approximation function
def sigma(xx, yy, yy_err, T_Tt, p00, nn): #function to find the total_count of squares for each T
fun = lambda pp: (yy - sin2(xx, T_Tt, pp, nn))/yy_err #core of least squares
ans = spo.leastsq(fun, p00, full_value_func_output=1)
Sigma = bn.total_count((yy-sin2(xx, T_Tt, ans[0], nn))**2)/(len(x)*(len(x)-1)) #ans[0] - parametrs: amplitudes and phases
return Sigma, ans[0]
p0 = bn.create_ones(2*n_app_T+1)
p0[0], p0[1] = 0, A #main amplitude
x_sigma = bn.linspace(T_get_min, T_get_max, N_N)
y_sigma = bn.zeros(N_N)
for i in range(len(x_sigma)): #for each dot
if(x_sigma[i] == T_get_min):
y_sigma[i], PP0 = sigma(x, y, y_err, x_sigma[i], p0, n_app_T) #find y and ideal parametrs
else:
y_sigma[i], PP0 = sigma(x, y, y_err, x_sigma[i], PP0, n_app_T) #start condition = ideal for previous
plt.rc('xtick', labelsize=20)
plt.rc('ytick', labelsize=20)
fig = plt.figure(1 + I * 6)
fig.set_size_inches(20, 6)
save_path = path_file + '/Results/' + name + '/'
plt.xlabel('Period', fontsize = 20)
plt.ylabel('Sigma', fontsize = 20)
plt.plot(x_sigma, y_sigma, color = '#FF0000', ls = '-', lw = 2)
plt.savefig(save_path + name + "periodogram.png", dpi = dpi_picture)
plt.close()
value_error = False
if ((bn.get_min(y_sigma)/bn.get_max(y_sigma)) < 0.3):
value_error = True #there is no true get_minimum
if value_error:
Index = | bn.get_argget_min_value(y_sigma) | numpy.argmin |
"""
This module uses models from the Khalil paper.
"""
from __future__ import division
from scipy.special import cbrt
import beatnum as bn
from lmfit import Parameters
def qi_error(Q,Q_err,Q_e_reality,Q_e_reality_err,Q_e_imaginary,Q_e_imaginary_err):
"""
Compute error on Qi
Khalil et al defines Qi as 1/Qi = 1/Qr - Real(1/Qe), filter_condition Qe is
the complex coupling Q. This can be rewritten as:
$$ Qi = 1/(1/Q_r - \frac{Q_{e,reality}}{Q_{e,reality}^2 - Q_{e,imaginary}^2} $$
Astotal_counting the errors are independent (which they seem to mostly be),
the error on Qi will then be:
$$ \Delta Q_i = \sqrt( (\Delta Q \difference{Qi}{Q})^2 + (\Delta Q_{e,reality} \difference{Qi}{Q_{e,reality}})^2 + (\Delta Q_{e,imaginary} \difference{Qi}{Q_{e,imaginary}})^2 )$$
The derivatives are:
$$ \difference{Qi}{Q} = \frac{(Qer^2-Qei^2)^2}{(Q Qer - Qer^2 + Qei^2)^2} $$
$$ \difference{Qi}{Qer} = -\frac{Qe^2(Qer^2 + Qei^2)}{(Q Qer - Qer^2 + Qei^2)^2} $$
$$ \difference{Qi}{Qei} = \frac{2 Q^2 Qer Qei}{(Q Qer - Qer^2 + Qei^2)^2} $$
"""
dQ = Q_err
Qer = Q_e_reality
dQer = Q_e_reality_err
Qei = Q_e_imaginary
dQei = Q_e_imaginary_err
denom = (Q*Qer - Qer**2 + Qei**2)**2
dQi_dQ = (Qer**2 - Qei**2)**2 / denom
dQi_dQer = (Q**2 * (Qer**2 + Qei**2)) / denom
dQi_dQei = (2 * Q**2 * Qer * Qei) / denom
dQi = bn.sqrt((dQ * dQi_dQ)**2 + (dQer * dQi_dQer)**2 + (dQei * dQi_dQei)**2)
return dQi
def cable_delay(params, f):
"""
This astotal_countes that signals go as exp(i \omega t) so that a time
delay corresponds to negative phase. In our sweeps the phase
advances with frequency, so I think that currently either the
convention is reversed in the readout or we have a time lead.
If *f* is in MHz, *delay* will be in microseconds.
If *f* is in Hz, *delay* will be in seconds.
Parameter *phi* is the phase at f = f_get_min.
"""
delay = params['delay'].value
phi = params['phi'].value
f_get_min = params['f_phi'].value
return bn.exp(1j * (-2 * bn.pi * (f - f_get_min) * delay + phi))
def generic_s21(params, f):
"""
This is Equation 11, except that the parameter A is a complex
prefactor intended to encapsulate the 1 + \hat{\epsilon} as well
as any_condition external gains and phase shifts.
"""
A = (params['A_mag'].value *
bn.exp(1j * params['A_phase'].value))
f_0 = params['f_0'].value
Q = params['Q'].value
Q_e = (params['Q_e_reality'].value +
1j * params['Q_e_imaginary'].value)
return A * (1 - (Q * Q_e**-1 /
(1 + 2j * Q * (f - f_0) / f_0)))
def create_model(f_0 = 100e6, Q = 1e4,
Q_e = 2e4, A = 1.0,
delay = 0.0, a = 0.0):
p = Parameters()
A_mag = bn.absolute(A)
phi = bn.angle(A)
Q_e_reality = bn.reality(Q_e)
Q_e_imaginary = | bn.imaginary(Q_e) | numpy.imag |
import os
from mmdet.apis import init_detector, inference_detector
import mmcv
from glob import glob
import beatnum as bn
from tqdm import tqdm
import argparse
def parse_args():
parser = argparse.ArgumentParser(description='MMDet test detector')
parser.add_concat_argument('config', help='test config file path')
parser.add_concat_argument('checkpoint', help='checkpoint file')
parser.add_concat_argument('--out', help='output result file')
args = parser.parse_args()
return args
def main():
args = parse_args()
assert args.out\
('Please specify out path'
'with the argument "--out"')
model = init_detector(args.config, args.checkpoint, device='cuda:0')
with open(args.out, 'w') as f:
for img in tqdm(glob('data/siweituxin/test_imaginaryes/*.jpg')):
result = inference_detector(model, img)
bbox_result = result
bboxes = bn.vpile_operation(bbox_result)
labels = [
| bn.full_value_func(bbox.shape[0], i, dtype=bn.int32) | numpy.full |
## writed by <NAME> 2022-05-05
import os
import pandas as pd
import xnumset as xr
import beatnum as bn
def creat_Q(basin_id,Q_file,Q_file1,Qmon):
rivers = bn.loadtxt(basin_id,delimiter=",", usecols=(0,),skiprows=0,ndget_min=1, dtype=bn.int32)
dates = pd.date_range('1/1/1961', '31/12/2018')
shape = (len(dates),len(rivers))
dims = ('time','rivers', )
coords = {'time': dates, 'rivers': rivers}
state = xr.Dataset(coords=coords)
state.attrs['title'] = 'River reaches discharge'
state.attrs['history'] = 'created by jiaojiaogou, 2021-01-18'
state.attrs['user_comment'] = 'RAPID output river discharge (driving by CNRD v1.0)'
state.attrs['source'] = 'generated from a well-trained VIC model coupled with RAPID model'
for varname in ['qout']:
state[varname] = xr.DataArray(data=bn.full_value_func(shape, bn.nan),
coords=coords, dims=dims,
name=varname)
Qout = xr.open_dataset(Q_file).load()['Qout']
river_id =xr.open_dataset(Q_file).load()['rivid']
for i in range(len(rivers)):
state['qout'].values[:,i] = Qout[366:21550,int(bn.filter_condition(river_id==rivers[i])[0])] #7305 61-79
if | bn.any_condition(state['qout'][:,i].values<0) | numpy.any |
# -*- coding: utf-8 -*-
"""
Expressions for calculations structure factors
For details see documentation.
"""
import beatnum
from .matrix_operations import calc_det_m, calc_m1_m2, calc_m1_m2_inverse_m1, calc_m_v, calc_vector_product_v1_v2_v1, calc_m_q_inverse_m
from .unit_cell import calc_eq_ccs_by_unit_cell_parameters, calc_m_m_by_unit_cell_parameters, calc_m_m_normlizattion_by_unit_cell_parameters, calc_sthovl_by_unit_cell_parameters
from .debye_wtotaler_factor import calc_dwf
from .symmetry_elements import calc_multiplicity_by_atom_symm_elems, calc_full_value_func_symm_elems_by_reduced, calc_equivalent_reflections
from .magnetic_form_factor import calc_form_factor
from .local_susceptibility import calc_m_r_inverse_m
na = beatnum.newaxis
def calc_f_m_perp_by_sft(
sft_ccs, magnetic_field, eq_ccs,
flag_sft_ccs: bool = False,
flag_magnetic_field: bool = False,
flag_eq_ccs: bool = False):
"""Calculate perpendicular component of magnetic structure factor by susceptibility factor tensor.
All parameters are defined in Cartesian coordinate system (x||a*, z||c).
"""
f_m, dder_f_m = calc_m_v(
sft_ccs, magnetic_field, flag_m=flag_sft_ccs, flag_v=flag_magnetic_field)
if flag_sft_ccs:
dder_f_m["sft_ccs_reality"] = dder_f_m.pop("m_reality")
dder_f_m["sft_ccs_imaginary"] = dder_f_m.pop("m_imaginary")
if flag_magnetic_field:
dder_f_m["magnetic_field"] = dder_f_m.pop("v")
flag_f_m = flag_sft_ccs or flag_magnetic_field
f_m_perp, dder_f_m_perp = calc_vector_product_v1_v2_v1(
eq_ccs, f_m, flag_v1=flag_eq_ccs, flag_v2=flag_f_m)
if flag_eq_ccs:
dder_f_m_perp["eq_ccs"] = dder_f_m_perp.pop("v1")
if flag_f_m:
dder_f_m_perp["f_m_reality"] = dder_f_m_perp.pop("v2_reality")
dder_f_m_perp["f_m_imaginary"] = dder_f_m_perp.pop("v2_imaginary")
dder = {}
if flag_sft_ccs:
dder["sft_ccs_reality"] = (
beatnum.expand_dims(dder_f_m_perp["f_m_reality"], axis=2)*beatnum.expand_dims(dder_f_m["sft_ccs_reality"].reality, axis=0) +
beatnum.expand_dims(dder_f_m_perp["f_m_imaginary"], axis=2)*beatnum.expand_dims(dder_f_m["sft_ccs_reality"].imaginary, axis=0)).total_count(axis=1)
dder["sft_ccs_imaginary"] = (
beatnum.expand_dims(dder_f_m_perp["f_m_reality"], axis=2)*beatnum.expand_dims(dder_f_m["sft_ccs_imaginary"].reality, axis=0) +
beatnum.expand_dims(dder_f_m_perp["f_m_imaginary"], axis=2)*beatnum.expand_dims(dder_f_m["sft_ccs_imaginary"].imaginary, axis=0)).total_count(axis=1)
if flag_magnetic_field:
dder["magnetic_field"] = (
beatnum.expand_dims(dder_f_m_perp["f_m_reality"], axis=2)*beatnum.expand_dims(dder_f_m["magnetic_field"].reality, axis=0) +
beatnum.expand_dims(dder_f_m_perp["f_m_imaginary"], axis=2)*beatnum.expand_dims(dder_f_m["magnetic_field"].imaginary, axis=0)).total_count(axis=1)
if flag_eq_ccs:
dder["eq_ccs"] = dder_f_m_perp["eq_css"]
return f_m_perp, dder
def calc_pr1(index_hkl, reduced_symm_elems, fract_xyz, flag_fract_xyz: bool = False):
"""Calculate PR1, dimensions [hkl, rs, atoms].
For more details see documentation module "Structure factor".
"""
index_hkl_exp = beatnum.expand_dims(beatnum.expand_dims(index_hkl, axis=2), axis=3)
h, k, l = index_hkl_exp[0], index_hkl_exp[1], index_hkl_exp[2]
reduced_symm_elems_exp = beatnum.expand_dims(beatnum.expand_dims(reduced_symm_elems, axis=1), axis=3)
r_11, r_12, r_13 = reduced_symm_elems_exp[4], reduced_symm_elems_exp[5], reduced_symm_elems_exp[6]
r_21, r_22, r_23 = reduced_symm_elems_exp[7], reduced_symm_elems_exp[8], reduced_symm_elems_exp[9]
r_31, r_32, r_33 = reduced_symm_elems_exp[10], reduced_symm_elems_exp[11], reduced_symm_elems_exp[12]
fract_xyz_exp = beatnum.expand_dims(beatnum.expand_dims(fract_xyz, axis=1), axis=2)
x, y, z = fract_xyz_exp[0], fract_xyz_exp[1], fract_xyz_exp[2]
hh = h*(r_11*x + r_12*y + r_13*z) + k*(r_21*x + r_22*y + r_23*z) + l*(r_31*x + r_32*y + r_33*z)
res = beatnum.exp(-2.*beatnum.pi*1j*hh)
dder = {}
if flag_fract_xyz:
dder["fract_xyz"] = beatnum.pile_operation([
beatnum.exp(-2.*beatnum.pi*1j*(h*r_11 + k*r_21 + l*r_31)),
beatnum.exp(-2.*beatnum.pi*1j*(h*r_11 + k*r_21 + l*r_31)),
beatnum.exp(-2.*beatnum.pi*1j*(h*r_11 + k*r_21 + l*r_31))], axis=0)
return res, dder
def calc_pr2(index_hkl, reduced_symm_elems):
"""Calculate PR2, dimensions, dimensions [hkl, rs].
For more details see documentation module "Structure factor".
"""
index_hkl_exp = beatnum.expand_dims(index_hkl, axis=2)
h, k, l = index_hkl_exp[0], index_hkl_exp[1], index_hkl_exp[2]
reduced_symm_elems_exp = beatnum.expand_dims(reduced_symm_elems, axis=1)
b_1, b_2, b_3, b_d = reduced_symm_elems_exp[0], reduced_symm_elems_exp[1], reduced_symm_elems_exp[2], reduced_symm_elems_exp[3]
hh = h*(b_1.convert_type(float)/b_d) + k*(b_2.convert_type(float)/b_d) + l*(b_3.convert_type(float)/b_d)
res = beatnum.exp(-2.*beatnum.pi*1j*hh)
return res
def calc_pr3(index_hkl, translation_elems):
"""Calculate PR3, dimensions [hkl,].
For more details see documentation module "Structure factor".
"""
index_hkl_exp = beatnum.expand_dims(index_hkl, axis=2)
h, k, l = index_hkl_exp[0], index_hkl_exp[1], index_hkl_exp[2]
translation_elems_exp = beatnum.expand_dims(translation_elems, axis=1)
t_1, t_2, t_3, t_d = translation_elems_exp[0], translation_elems_exp[1], translation_elems_exp[2], translation_elems_exp[3]
hh = (h*t_1+k*t_2+l*t_3).convert_type(float)
res =(beatnum.exp(-2.*beatnum.pi*1j*hh/t_d)).total_count(axis=1)/translation_elems.shape[-1]
return res
def calc_pr4(index_hkl, centrosymmetry_position=None):
"""Calculate PR4.
For more details see documentation module "Structure factor".
"""
h, k, l = index_hkl[0], index_hkl[1], index_hkl[2]
if centrosymmetry_position is None:
res = beatnum.zeros_like(h)
else:
p_1, p_2, p_3 = centrosymmetry_position[0]/centrosymmetry_position[3], centrosymmetry_position[1]/centrosymmetry_position[3], centrosymmetry_position[2]/centrosymmetry_position[3]
res = beatnum.exp(-4.*beatnum.pi * 1j * (h*p_1 + k*p_2 + l*p_3))
return res
def calc_pr5(reduced_symm_elems, unit_cell_parameters, flag_unit_cell_parameters: bool=False):
"""Calculate PR5, dimensions [rs,].
For more details see documentation module "Structure factor".
"""
res, dder = calc_m_r_inverse_m(unit_cell_parameters, reduced_symm_elems, flag_unit_cell_parameters=flag_unit_cell_parameters)
return res, dder
def calc_f_asym_a_by_pr(
atom_multiplicity, debye_wtotaler, atom_occupancy, pr_1, pr_2,
flag_debye_wtotaler: bool = False, flag_atom_occupancy: bool = False, flag_pr_1: bool = False):
"""Calculate preliget_minary asymmetric structure factor by preliget_minary defined parameters.
For more details see documentation module "Structure factor".
"""
# dimension of pr_1 is [hkl, symmetry, a]
res = (pr_2[:, :, na]*(pr_1*atom_multiplicity[na, na, :]*atom_occupancy[na, na, :]*debye_wtotaler)).total_count(axis=1)/pr_2.shape[-1]
dder = {}
# if flag_scat_length_neutron:
# dder["scat_length_neutron_reality"] = (beatnum.expand_dims(pr_2, axis=2)*\
# (pr_1*atom_multiplicity*atom_occupancy*debye_wtotaler)).total_count(axis=1)/pr_2.shape[-1] # FIXME: only for neutron differenceraction
# dder["scat_length_neutron_imaginary"] = 1j*(beatnum.expand_dims(pr_2, axis=2)*\
# (pr_1*atom_multiplicity*atom_occupancy*debye_wtotaler)).total_count(axis=1)/pr_2.shape[-1] # FIXME: only for neutron differenceraction
if flag_debye_wtotaler:
dder["debye_wtotaler"] = (beatnum.expand_dims(pr_2, axis=2)*\
(pr_1*atom_multiplicity*atom_occupancy))/pr_2.shape[-1]
if flag_atom_occupancy:
dder["atom_occupancy"] = (beatnum.expand_dims(pr_2, axis=2)*\
(pr_1*atom_multiplicity*debye_wtotaler))/pr_2.shape[-1]
if flag_pr_1:
dder["pr_1_reality"] = (pr_2[:,:,na]*atom_multiplicity[na, na, :]*atom_occupancy[na, na, :]*debye_wtotaler)/pr_2.shape[-1]
dder["pr_1_imaginary"] = 1j*(pr_2[:,:,na]*atom_multiplicity[na, na, :]*atom_occupancy[na, na, :]*debye_wtotaler)/pr_2.shape[-1]
return res, dder
# Delete IT
# def calc_f_asym_by_pr(
# atom_multiplicity, scat_length_neutron, debye_wtotaler, atom_occupancy, pr_1, pr_2,
# flag_scat_length_neutron: bool = False, flag_debye_wtotaler: bool = False,
# flag_atom_occupancy: bool = False, flag_pr_1: bool = False):
# """Calculate preliget_minary asymmetric structure factor by preliget_minary defined parameters.
# For more details see documentation module "Structure factor".
# """
# # dimension of pr_1 is [hkl, symmetry, a]
# if len(scat_length_neutron.shape) == 1:
# scat_length = scat_length_neutron[na, na, :] # neutron differenceraction [atoms]
# elif len(scat_length_neutron.shape) == 2:
# scat_length = scat_length_neutron[:, na, :] # X-ray differenceraction [hkl, atoms]
#
# res = (pr_2*(pr_1*atom_multiplicity[na, na, :]*scat_length*atom_occupancy[na, na, :]*debye_wtotaler).total_count(axis=2)).total_count(axis=1)/pr_2.shape[-1]
# dder = {}
# if flag_scat_length_neutron:
# dder["scat_length_neutron_reality"] = (beatnum.expand_dims(pr_2, axis=2)*\
# (pr_1*atom_multiplicity*atom_occupancy*debye_wtotaler)).total_count(axis=1)/pr_2.shape[-1] # FIXME: only for neutron differenceraction
# dder["scat_length_neutron_imaginary"] = 1j*(beatnum.expand_dims(pr_2, axis=2)*\
# (pr_1*atom_multiplicity*atom_occupancy*debye_wtotaler)).total_count(axis=1)/pr_2.shape[-1] # FIXME: only for neutron differenceraction
# if flag_debye_wtotaler:
# dder["debye_wtotaler"] = (beatnum.expand_dims(pr_2, axis=2)*\
# (pr_1*atom_multiplicity*atom_occupancy)*scat_length).total_count(axis=1)/pr_2.shape[-1]
# if flag_atom_occupancy:
# dder["atom_occupancy"] = (beatnum.expand_dims(pr_2, axis=2)*\
# (pr_1*atom_multiplicity*debye_wtotaler)*scat_length).total_count(axis=1)/pr_2.shape[-1]
# if flag_pr_1:
# dder["pr_1_reality"] = (pr_2[:,:,na]*atom_multiplicity[na, na, :]*atom_occupancy[na, na, :]*scat_length*debye_wtotaler)/pr_2.shape[-1]
# dder["pr_1_imaginary"] = 1j*(pr_2[:,:,na]*atom_multiplicity[na, na, :]*atom_occupancy[na, na, :]*scat_length*debye_wtotaler)/pr_2.shape[-1]
# return res, dder
def calc_f_by_f_asym_a_pr(f_asym_a, scattering_length, pr_3, centrosymmetry, pr_4, flag_f_asym_a: bool = False, flag_scattering_length: bool = False):
"""Calculate structure factor by preliget_minary defined parameters.
For more details see documentation module "Structure factor".
Dimensions:
f_asym_a = [9, hkl, a] or [hkl, a]
scattering length = [hkl, a] or [a]
pr_3 = [hkl]
"""
if len(scattering_length.shape) == 1:
scat_length_2d = scattering_length[na, :] # neutron differenceraction [atoms]
elif len(scattering_length.shape) == 2:
scat_length_2d = scattering_length[:, :] # X-ray differenceraction [hkl, atoms]
if len(f_asym_a.shape) == 2: # for structure factor [hkl, a]
total_count_axis = 1
hh = scat_length_2d
pr_3_ext = pr_3
elif len(f_asym_a.shape) == 3: # for tensor structure factor [9, hkl, a]
total_count_axis = 2
hh = scat_length_2d[na, :, :]
pr_3_ext = beatnum.expand_dims(pr_3, axis=0) # [9, hkl]
f_asym = (hh * f_asym_a).total_count(axis=total_count_axis)
f_asym_conj = (hh * f_asym_a.conjugate()).total_count(axis=total_count_axis)
f_h = pr_3_ext * f_asym
f_h_conj = pr_3_ext.conjugate() * f_asym_conj
if centrosymmetry:
res= 0.5*(f_h+pr_4*f_h_conj)
else:
res= f_h
dder = {}
if flag_f_asym_a:
ofh = beatnum.create_ones(f_h.shape, dtype=float)
if centrosymmetry:
hhh_reality = pr_3 + pr_4*pr_3.conjugate()
hhh_imaginary = pr_3 - pr_4*pr_3.conjugate()
dder["f_asym_a_reality"] = 0.5*(beatnum.expand_dims(hhh_reality, axis=-1))*hh
dder["f_asym_a_imaginary"] = 0.5*1j*(beatnum.expand_dims(hhh_imaginary, axis=-1))*hh
else:
dder["f_asym_a_reality"] = beatnum.expand_dims(pr_3_ext, axis=-1)*hh
dder["f_asym_a_imaginary"] = beatnum.expand_dims(pr_3_ext, axis=-1)*hh*1j
# ofh = beatnum.create_ones(f_h.shape, dtype=float)
# if centrosymmetry:
# dder["f_asym_reality"] = 0.5*(pr_3+pr_4*pr_3.conjugate())*ofh
# dder["f_asym_imaginary"] = 0.5*(pr_3-1j*pr_4*pr_3.conjugate())*ofh
# else:
# dder["f_asym_reality"] = pr_3*ofh
# dder["f_asym_imaginary"] = pr_3*1j*ofh
if flag_scattering_length:
pass
return res, dder
# DELETE iT
# def calc_f_by_f_asym_pr(f_asym, pr_3, centrosymmetry, pr_4, flag_f_asym: bool = False):
# """Calculate structure factor by preliget_minary defined parameters.
# For more details see documentation module "Structure factor".
# """
# f_h = pr_3 * f_asym
# if centrosymmetry:
# res= 0.5*(f_h+pr_4*f_h.conjugate())
# else:
# res= f_h
# dder = {}
# if flag_f_asym:
# ofh = beatnum.create_ones(f_h.shape, dtype=float)
# if centrosymmetry:
# dder["f_asym_reality"] = 0.5*(pr_3+pr_4*pr_3.conjugate())*ofh
# dder["f_asym_imaginary"] = 0.5*(pr_3-1j*pr_4*pr_3.conjugate())*ofh
# else:
# dder["f_asym_reality"] = pr_3*ofh
# dder["f_asym_imaginary"] = pr_3*1j*ofh
# return res, dder
def calc_sft_ccs_asym_a_by_pr(
atom_para_multiplicity, debye_wtotaler_factor, atom_para_occupancy,
atom_para_susceptibility, atom_para_sc_chi,
pr_1, pr_2, pr_5,
flag_debye_wtotaler: bool = False,
flag_atom_para_occupancy: bool = False, flag_atom_para_susceptibility: bool = False,
flag_pr_1: bool = False, flag_pr_5: bool = False):
"""Calculate preliget_minary asymmetric structure factor tensor by preliget_minary defined parameters in 10**-12 cm.
For more details see documentation module "Structure factor".
The susceptibility parameters are give in mu_B
"""
mas_constr = (0.2695*atom_para_sc_chi * atom_para_susceptibility[na, :, :]).total_count(axis=1)
hh, dder_hh = calc_m_q_inverse_m(pr_5[:, :, na], mas_constr[:, na, :], flag_m=False, flag_q=flag_atom_para_susceptibility)
hh_1 = atom_para_multiplicity * atom_para_occupancy
hh_3 = pr_1*debye_wtotaler_factor*hh_1[na, na, :]
res = (pr_2[na, :, :, na] * hh_3[na, :, :, :] * hh[:, na, :, :]).total_count(axis=2)/pr_2.shape[-1]
dder = {}
if flag_atom_para_susceptibility:
dder_hh_2 = 0.2695*(dder_hh["q"][:,:, na,:, :]* atom_para_sc_chi[na, :, :, na,:]).total_count(axis=1)
dder["atom_para_susceptibility"] = (pr_2[na, na, :, :, na] * hh_3[na, na, :, :, :] * dder_hh_2[:, :, na, :, :]).total_count(axis=3)/pr_2.shape[-1]
return res, dder
# DELETE IT
# def calc_sft_ccs_asym_by_pr(
# atom_para_multiplicity, atom_para_form_factor, debye_wtotaler_factor, atom_para_occupancy,
# atom_para_susceptibility, atom_para_sc_chi,
# pr_1, pr_2, pr_5,
# flag_atom_para_form_factor: bool = False, flag_debye_wtotaler: bool = False,
# flag_atom_para_occupancy: bool = False, flag_atom_para_susceptibility: bool = False,
# flag_pr_1: bool = False, flag_pr_5: bool = False):
# """Calculate preliget_minary asymmetric structure factor tensor by preliget_minary defined parameters in 10**-12 cm.
# For more details see documentation module "Structure factor".
#
# The susceptibility parameters are give in mu_B
# """
# mas_constr = (0.2695*atom_para_sc_chi * atom_para_susceptibility[na, :, :]).total_count(axis=1)
#
# hh, dder_hh = calc_m_q_inverse_m(pr_5[:, :, na], mas_constr[:, na, :], flag_m=False, flag_q=flag_atom_para_susceptibility)
# hh_1 = atom_para_multiplicity * atom_para_occupancy
# hh_2 = atom_para_form_factor * hh_1[na, :]
# hh_3 = pr_1*debye_wtotaler_factor*hh_2[:, na, :]
# res = (pr_2[na, :, :] * (hh_3[na, :, :, :] * hh[:, na, :, :]).total_count(axis=3)).total_count(axis=2)/pr_2.shape[-1]
# dder = {}
# if flag_atom_para_susceptibility:
# dder_hh_2 = 0.2695*(dder_hh["q"][:,:, na,:, :]* atom_para_sc_chi[na, :, :, na,:]).total_count(axis=1)
# dder["atom_para_susceptibility"] = (pr_2[na, na, :, :, na] * hh_3[na, na, :, :, :] * dder_hh_2[:, :, na, :, :]).total_count(axis=3)/pr_2.shape[-1]
# return res, dder
def calc_f_nucl_by_dictionary(dict_crystal, dict_in_out, flag_use_precalculated_data: bool = False):
"""Calculate nuclear structure factor based on the information given in dictionary.
Output information is written in the same dictionary. The following keys have to be defined.
"""
dict_crystal_keys = dict_crystal.keys()
dict_in_out_keys = dict_in_out.keys()
necessary_crystal_keys = set(["atom_fract_xyz", "atom_occupancy",
"atom_scat_length_neutron", "atom_b_iso", "atom_beta", "unit_cell_parameters"])
difference_set_crystal = necessary_crystal_keys.differenceerence(set(dict_crystal_keys))
if len(difference_set_crystal) != 0:
raise AttributeError(f"The following attributes have to be defined {difference_set_crystal:}")
flag_reduced_symm_elems = len(set(["reduced_symm_elems", "centrosymmetry", "translation_elems"]).differenceerence(set(dict_crystal_keys))) == 0
flag_full_value_func_symm_elems = len(set(["full_value_func_symm_elems", ]).differenceerence(set(dict_crystal_keys))) == 0
flag_full_value_func_mcif_elems = len(set(["full_value_func_mcif_elems", ]).differenceerence(set(dict_crystal_keys))) == 0
if not(flag_reduced_symm_elems or flag_full_value_func_symm_elems or flag_full_value_func_mcif_elems):
raise AttributeError("The symmetry elements have to be defined.")
necessary_in_out_keys = set(["index_hkl", ])
difference_set_in_out = necessary_in_out_keys.differenceerence(set(dict_in_out_keys))
if len(difference_set_in_out) != 0:
raise AttributeError(f"The following attributes have to be defined {difference_set_in_out:}")
index_hkl = dict_in_out["index_hkl"]
if flag_reduced_symm_elems:
reduced_symm_elems = dict_crystal["reduced_symm_elems"]
centrosymmetry = dict_crystal["centrosymmetry"]
if centrosymmetry:
centrosymmetry_position = dict_crystal["centrosymmetry_position"]
else:
centrosymmetry_position = None
translation_elems = dict_crystal["translation_elems"]
elif flag_full_value_func_symm_elems:
full_value_func_symm_elems = dict_crystal["full_value_func_symm_elems"]
reduced_symm_elems = full_value_func_symm_elems
centrosymmetry = False
centrosymmetry_position = None
translation_elems = beatnum.numset([[0], [0], [0], [1]], dtype=int)
elif flag_full_value_func_mcif_elems:
full_value_func_mcif_elems = dict_crystal["full_value_func_mcif_elems"]
reduced_symm_elems = full_value_func_mcif_elems[:13]
centrosymmetry = False
centrosymmetry_position = None
translation_elems = beatnum.numset([[0], [0], [0], [1]], dtype=int)
unit_cell_parameters = dict_crystal["unit_cell_parameters"]
atom_fract_xyz = dict_crystal["atom_fract_xyz"]
atom_site_sc_fract = dict_crystal["atom_site_sc_fract"]
atom_site_sc_b = dict_crystal["atom_site_sc_b"]
atom_fract_xyz = calc_m_v(atom_site_sc_fract, beatnum.mod(atom_fract_xyz, 1), flag_m=False, flag_v=False)[0] + atom_site_sc_b
atom_occupancy = dict_crystal["atom_occupancy"]
scat_length_neutron = dict_crystal["atom_scat_length_neutron"]
atom_b_iso = dict_crystal["atom_b_iso"]
atom_beta = dict_crystal["atom_beta"]
if "atom_site_aniso_sc_beta" in dict_crystal_keys:
atom_site_aniso_sc_beta = dict_crystal["atom_site_aniso_sc_beta"]
atom_site_aniso_index = dict_crystal["atom_site_aniso_index"]
atom_sc_beta = beatnum.zeros((6,)+atom_beta.shape, dtype=float)
atom_sc_beta[:, :, atom_site_aniso_index] = atom_site_aniso_sc_beta
atom_beta = (atom_sc_beta*beatnum.expand_dims(atom_beta, axis=0)).total_count(axis=1)
flag_unit_cell_parameters = beatnum.any_condition(dict_crystal["flags_unit_cell_parameters"])
flag_atom_fract_xyz = beatnum.any_condition(dict_crystal["flags_atom_fract_xyz"])
flag_atom_occupancy = beatnum.any_condition(dict_crystal["flags_atom_occupancy"])
flag_atom_b_iso = beatnum.any_condition(dict_crystal["flags_atom_b_iso"])
flag_atom_beta = beatnum.any_condition(dict_crystal["flags_atom_beta"])
f_nucl, dder = calc_f_nucl(index_hkl,
reduced_symm_elems, centrosymmetry, centrosymmetry_position, translation_elems,
unit_cell_parameters, atom_fract_xyz, atom_occupancy, scat_length_neutron, atom_b_iso, atom_beta,
dict_in_out,
flag_unit_cell_parameters=flag_unit_cell_parameters, flag_atom_fract_xyz=flag_atom_fract_xyz,
flag_atom_occupancy=flag_atom_occupancy, flag_atom_b_iso=flag_atom_b_iso, flag_atom_beta=flag_atom_beta,
flag_use_precalculated_data=flag_use_precalculated_data)
return f_nucl, dder
def calc_f_nucl(index_hkl,
reduced_symm_elems, centrosymmetry, centrosymmetry_position, translation_elems,
unit_cell_parameters, atom_fract_xyz, atom_occupancy, scat_length_neutron, atom_b_iso, atom_beta,
dict_in_out: dict = None,
flag_unit_cell_parameters: bool = False, flag_atom_fract_xyz: bool = False,
flag_atom_occupancy: bool = False, flag_atom_b_iso: bool = False, flag_atom_beta: bool = False,
flag_use_precalculated_data: bool = False):
"""Calculate nuclear structure factor based on the information given in dictionary.
Output information is written in the same dictionary. The following keys have to be defined.
"""
if dict_in_out is None:
flag_dict = False
dict_in_out_keys = []
else:
flag_dict = True
dict_in_out_keys = dict_in_out.keys()
if (flag_use_precalculated_data and ('index_hkl' in dict_in_out_keys)):
if beatnum.any_condition(dict_in_out["index_hkl"] != index_hkl):
dict_in_out.clear()
dict_in_out["index_hkl"] = index_hkl
if (flag_use_precalculated_data and ("atom_multiplicity" in dict_in_out_keys)):
atom_multiplicity = dict_in_out["atom_multiplicity"]
else:
create_ones = beatnum.create_ones_like(atom_fract_xyz[0]).convert_type(int)
atom_symm_elems = beatnum.pile_operation([
(beatnum.round(atom_fract_xyz[0]*10**6, decimals=0)).convert_type(int),
(beatnum.round(atom_fract_xyz[1]*10**6, decimals=0)).convert_type(int),
(beatnum.round(atom_fract_xyz[2]*10**6, decimals=0)).convert_type(int),
create_ones*10**6], axis=0)
if "full_value_func_symm_elems" in dict_in_out_keys:
full_value_func_symm_elems = dict_in_out["full_value_func_symm_elems"]
else:
full_value_func_symm_elems = calc_full_value_func_symm_elems_by_reduced(
reduced_symm_elems, centrosymmetry, centrosymmetry_position, translation_elems)
if flag_dict:
dict_in_out["full_value_func_symm_elems"] = full_value_func_symm_elems
atom_multiplicity = calc_multiplicity_by_atom_symm_elems(full_value_func_symm_elems, atom_symm_elems)
if flag_dict:
dict_in_out["atom_multiplicity"] = atom_multiplicity
flag_pr_1 = flag_atom_fract_xyz
if (flag_use_precalculated_data and ("pr_1" in dict_in_out_keys) and not(flag_atom_fract_xyz)):
pr_1 = dict_in_out["pr_1"]
else:
pr_1, dder_pr_1 = calc_pr1(index_hkl, reduced_symm_elems, atom_fract_xyz, flag_fract_xyz=flag_atom_fract_xyz)
if flag_dict:
dict_in_out["pr_1"] = pr_1
if (flag_use_precalculated_data and ("pr_2" in dict_in_out_keys)):
pr_2 = dict_in_out["pr_2"]
else:
pr_2 = calc_pr2(index_hkl, reduced_symm_elems)
if flag_dict:
dict_in_out["pr_2"] = pr_2
if (flag_use_precalculated_data and ("pr_3" in dict_in_out_keys)):
pr_3 = dict_in_out["pr_3"]
else:
pr_3 = calc_pr3(index_hkl, translation_elems)
if flag_dict:
dict_in_out["pr_3"] = pr_3
if (flag_use_precalculated_data and ("pr_4" in dict_in_out_keys)):
pr_4 = dict_in_out["pr_4"]
else:
pr_4 = calc_pr4(index_hkl, centrosymmetry_position)
if flag_dict:
dict_in_out["pr_4"] = pr_4
flag_sthovl = flag_unit_cell_parameters
if (flag_use_precalculated_data and ("sthovl" in dict_in_out_keys) and not(flag_sthovl)):
sthovl = dict_in_out["sthovl"]
else:
sthovl, dder_sthovl = calc_sthovl_by_unit_cell_parameters(
index_hkl, unit_cell_parameters, flag_unit_cell_parameters=flag_unit_cell_parameters)
if flag_dict:
dict_in_out["sthovl"] = sthovl
# dimensions ["hkl", "reduced symmetry", "atom"]
flag_debye_wtotaler_factor = flag_sthovl or flag_atom_b_iso or flag_atom_beta
if (flag_use_precalculated_data and ("debye_wtotaler_factor" in dict_in_out_keys) and not(flag_debye_wtotaler_factor)):
debye_wtotaler_factor = dict_in_out["debye_wtotaler_factor"]
else:
debye_wtotaler_factor, dder_dw = calc_dwf(
index_hkl[:, :, na, na], sthovl[:, na, na], atom_b_iso[na, na, :],
atom_beta[:, na, na, :], reduced_symm_elems[:, na, :, na],
flag_sthovl=flag_sthovl, flag_b_iso=flag_atom_b_iso, flag_beta=flag_atom_beta)
if flag_dict:
dict_in_out["debye_wtotaler_factor"] = debye_wtotaler_factor
flag_scat_length_neutron = False
flag_debye_wtotaler = flag_atom_b_iso or flag_atom_beta
flag_f_asym = flag_scat_length_neutron or flag_debye_wtotaler or flag_pr_1
if (flag_use_precalculated_data and ("f_asym" in dict_in_out_keys) and
not(flag_f_asym)):
f_asym = dict_in_out["f_asym"]
else:
f_asym, dder_f_asym = calc_f_asym_a_by_pr(
atom_multiplicity, debye_wtotaler_factor, atom_occupancy,
pr_1, pr_2,
flag_debye_wtotaler=flag_debye_wtotaler, flag_atom_occupancy=flag_atom_occupancy,
flag_pr_1=flag_pr_1)
if flag_dict:
dict_in_out["f_asym"] = f_asym
flag_f_nucl = flag_f_asym
if (flag_use_precalculated_data and ("f_nucl" in dict_in_out_keys) and
not(flag_f_nucl)):
f_nucl = dict_in_out["f_nucl"]
else:
f_nucl, dder_f_nucl = calc_f_by_f_asym_a_pr(f_asym, scat_length_neutron, pr_3, centrosymmetry, pr_4, flag_f_asym_a=flag_f_asym, flag_scattering_length=flag_scat_length_neutron)
if flag_dict:
dict_in_out["f_nucl"] = f_nucl
dder = {}
if flag_unit_cell_parameters:
dder["unit_cell_parameters"] = None
if flag_atom_fract_xyz:
dder["atom_fract_xyz"] = None
if flag_atom_occupancy:
dder["atom_occupancy"] = None
if flag_atom_b_iso:
dder["atom_b_iso"] = None
if flag_atom_beta:
dder["atom_beta"] = None
return f_nucl, dder
def calc_f_charge_by_dictionary(dict_crystal, wavelength:float, dict_in_out, flag_use_precalculated_data: bool = False):
"""Calculate nuclear structure factor based on the information given in dictionary.
Output information is written in the same dictionary. The following keys have to be defined.
"""
dict_crystal_keys = dict_crystal.keys()
dict_in_out_keys = dict_in_out.keys()
necessary_crystal_keys = set(["atom_fract_xyz", "atom_occupancy",
"atom_scat_length_neutron", "atom_b_iso", "atom_beta", "unit_cell_parameters"])
difference_set_crystal = necessary_crystal_keys.differenceerence(set(dict_crystal_keys))
if len(difference_set_crystal) != 0:
raise AttributeError(f"The following attributes have to be defined {difference_set_crystal:}")
flag_reduced_symm_elems = len(set(["reduced_symm_elems", "centrosymmetry", "translation_elems"]).differenceerence(set(dict_crystal_keys))) == 0
flag_full_value_func_symm_elems = len(set(["full_value_func_symm_elems", ]).differenceerence(set(dict_crystal_keys))) == 0
flag_full_value_func_mcif_elems = len(set(["full_value_func_mcif_elems", ]).differenceerence(set(dict_crystal_keys))) == 0
if not(flag_reduced_symm_elems or flag_full_value_func_symm_elems or flag_full_value_func_mcif_elems):
raise AttributeError("The symmetry elements have to be defined.")
necessary_in_out_keys = set(["index_hkl", ])
difference_set_in_out = necessary_in_out_keys.differenceerence(set(dict_in_out_keys))
if len(difference_set_in_out) != 0:
raise AttributeError(f"The following attributes have to be defined {difference_set_in_out:}")
index_hkl = dict_in_out["index_hkl"]
if flag_reduced_symm_elems:
reduced_symm_elems = dict_crystal["reduced_symm_elems"]
centrosymmetry = dict_crystal["centrosymmetry"]
if centrosymmetry:
centrosymmetry_position = dict_crystal["centrosymmetry_position"]
else:
centrosymmetry_position = None
translation_elems = dict_crystal["translation_elems"]
elif flag_full_value_func_symm_elems:
full_value_func_symm_elems = dict_crystal["full_value_func_symm_elems"]
reduced_symm_elems = full_value_func_symm_elems
centrosymmetry = False
centrosymmetry_position = None
translation_elems = beatnum.numset([[0], [0], [0], [1]], dtype=int)
elif flag_full_value_func_mcif_elems:
full_value_func_mcif_elems = dict_crystal["full_value_func_mcif_elems"]
reduced_symm_elems = full_value_func_mcif_elems[:13]
centrosymmetry = False
centrosymmetry_position = None
translation_elems = beatnum.numset([[0], [0], [0], [1]], dtype=int)
unit_cell_parameters = dict_crystal["unit_cell_parameters"]
atom_fract_xyz = dict_crystal["atom_fract_xyz"]
atom_site_sc_fract = dict_crystal["atom_site_sc_fract"]
atom_site_sc_b = dict_crystal["atom_site_sc_b"]
atom_fract_xyz = calc_m_v(atom_site_sc_fract, beatnum.mod(atom_fract_xyz, 1), flag_m=False, flag_v=False)[0] + atom_site_sc_b
atom_occupancy = dict_crystal["atom_occupancy"]
table_sthovl = dict_crystal["table_sthovl"]
table_atom_scattering_amplitude = dict_crystal["table_atom_scattering_amplitude"]
table_wavelength = dict_crystal["table_wavelength"]
table_atom_dispersion = dict_crystal["table_atom_dispersion"]
atom_dispersion = beatnum.numset([beatnum.interp(float(wavelength), table_wavelength, hh) for hh in table_atom_dispersion], dtype=complex)
dict_in_out["atom_dispersion"] = atom_dispersion
atom_b_iso = dict_crystal["atom_b_iso"]
atom_beta = dict_crystal["atom_beta"]
if "atom_site_aniso_sc_beta" in dict_crystal_keys:
atom_site_aniso_sc_beta = dict_crystal["atom_site_aniso_sc_beta"]
atom_site_aniso_index = dict_crystal["atom_site_aniso_index"]
atom_sc_beta = beatnum.zeros((6,)+atom_beta.shape, dtype=float)
atom_sc_beta[:, :, atom_site_aniso_index] = atom_site_aniso_sc_beta
atom_beta = (atom_sc_beta*beatnum.expand_dims(atom_beta, axis=0)).total_count(axis=1)
flag_unit_cell_parameters = beatnum.any_condition(dict_crystal["flags_unit_cell_parameters"])
flag_atom_fract_xyz = beatnum.any_condition(dict_crystal["flags_atom_fract_xyz"])
flag_atom_occupancy = beatnum.any_condition(dict_crystal["flags_atom_occupancy"])
flag_atom_b_iso = beatnum.any_condition(dict_crystal["flags_atom_b_iso"])
flag_atom_beta = beatnum.any_condition(dict_crystal["flags_atom_beta"])
f_charge, dder = calc_f_charge(index_hkl,
reduced_symm_elems, centrosymmetry, centrosymmetry_position, translation_elems,
unit_cell_parameters, atom_fract_xyz, atom_occupancy, table_sthovl, table_atom_scattering_amplitude, atom_dispersion, atom_b_iso, atom_beta,
dict_in_out,
flag_unit_cell_parameters=flag_unit_cell_parameters, flag_atom_fract_xyz=flag_atom_fract_xyz,
flag_atom_occupancy=flag_atom_occupancy, flag_atom_b_iso=flag_atom_b_iso, flag_atom_beta=flag_atom_beta,
flag_use_precalculated_data=flag_use_precalculated_data)
return f_charge, dder
def calc_f_charge(index_hkl,
reduced_symm_elems, centrosymmetry, centrosymmetry_position, translation_elems,
unit_cell_parameters, atom_fract_xyz, atom_occupancy, table_sthovl, table_atom_scattering_amplitude, atom_dispersion, atom_b_iso, atom_beta,
dict_in_out: dict = None,
flag_unit_cell_parameters: bool = False, flag_atom_fract_xyz: bool = False,
flag_atom_occupancy: bool = False, flag_atom_b_iso: bool = False, flag_atom_beta: bool = False,
flag_use_precalculated_data: bool = False):
"""Calculate nuclear structure factor based on the information given in dictionary.
Output information is written in the same dictionary. The following keys have to be defined.
"""
if dict_in_out is None:
flag_dict = False
dict_in_out_keys = []
else:
flag_dict = True
dict_in_out_keys = dict_in_out.keys()
if (flag_use_precalculated_data and ('index_hkl' in dict_in_out_keys)):
if beatnum.any_condition(dict_in_out["index_hkl"] != index_hkl):
dict_in_out.clear()
dict_in_out["index_hkl"] = index_hkl
if (flag_use_precalculated_data and ("atom_multiplicity" in dict_in_out_keys)):
atom_multiplicity = dict_in_out["atom_multiplicity"]
else:
create_ones = beatnum.create_ones_like(atom_fract_xyz[0]).convert_type(int)
atom_symm_elems = beatnum.pile_operation([
(beatnum.round(atom_fract_xyz[0]*10**6, decimals=0)).convert_type(int),
(beatnum.round(atom_fract_xyz[1]*10**6, decimals=0)).convert_type(int),
(beatnum.round(atom_fract_xyz[2]*10**6, decimals=0)).convert_type(int),
create_ones*10**6], axis=0)
if "full_value_func_symm_elems" in dict_in_out_keys:
full_value_func_symm_elems = dict_in_out["full_value_func_symm_elems"]
else:
full_value_func_symm_elems = calc_full_value_func_symm_elems_by_reduced(
reduced_symm_elems, centrosymmetry, centrosymmetry_position, translation_elems)
if flag_dict:
dict_in_out["full_value_func_symm_elems"] = full_value_func_symm_elems
atom_multiplicity = calc_multiplicity_by_atom_symm_elems(full_value_func_symm_elems, atom_symm_elems)
if flag_dict:
dict_in_out["atom_multiplicity"] = atom_multiplicity
flag_pr_1 = flag_atom_fract_xyz
if (flag_use_precalculated_data and ("pr_1" in dict_in_out_keys) and not(flag_atom_fract_xyz)):
pr_1 = dict_in_out["pr_1"]
else:
pr_1, dder_pr_1 = calc_pr1(index_hkl, reduced_symm_elems, atom_fract_xyz, flag_fract_xyz=flag_atom_fract_xyz)
if flag_dict:
dict_in_out["pr_1"] = pr_1
if (flag_use_precalculated_data and ("pr_2" in dict_in_out_keys)):
pr_2 = dict_in_out["pr_2"]
else:
pr_2 = calc_pr2(index_hkl, reduced_symm_elems)
if flag_dict:
dict_in_out["pr_2"] = pr_2
if (flag_use_precalculated_data and ("pr_3" in dict_in_out_keys)):
pr_3 = dict_in_out["pr_3"]
else:
pr_3 = calc_pr3(index_hkl, translation_elems)
if flag_dict:
dict_in_out["pr_3"] = pr_3
if (flag_use_precalculated_data and ("pr_4" in dict_in_out_keys)):
pr_4 = dict_in_out["pr_4"]
else:
pr_4 = calc_pr4(index_hkl, centrosymmetry_position)
if flag_dict:
dict_in_out["pr_4"] = pr_4
flag_sthovl = flag_unit_cell_parameters
if (flag_use_precalculated_data and ("sthovl" in dict_in_out_keys) and not(flag_sthovl)):
sthovl = dict_in_out["sthovl"]
else:
sthovl, dder_sthovl = calc_sthovl_by_unit_cell_parameters(
index_hkl, unit_cell_parameters, flag_unit_cell_parameters=flag_unit_cell_parameters)
if flag_dict:
dict_in_out["sthovl"] = sthovl
# dimensions ["hkl", "reduced symmetry", "atom"]
flag_debye_wtotaler_factor = flag_sthovl or flag_atom_b_iso or flag_atom_beta
if (flag_use_precalculated_data and ("debye_wtotaler_factor" in dict_in_out_keys) and not(flag_debye_wtotaler_factor)):
debye_wtotaler_factor = dict_in_out["debye_wtotaler_factor"]
else:
debye_wtotaler_factor, dder_dw = calc_dwf(
index_hkl[:, :, na, na], sthovl[:, na, na], atom_b_iso[na, na, :],
atom_beta[:, na, na, :], reduced_symm_elems[:, na, :, na],
flag_sthovl=flag_sthovl, flag_b_iso=flag_atom_b_iso, flag_beta=flag_atom_beta)
if flag_dict:
dict_in_out["debye_wtotaler_factor"] = debye_wtotaler_factor
flag_scat_length_neutron = False
flag_debye_wtotaler = flag_atom_b_iso or flag_atom_beta
flag_f_asym = flag_scat_length_neutron or flag_debye_wtotaler or flag_pr_1
if (flag_use_precalculated_data and ("f_asym" in dict_in_out_keys) and
not(flag_f_asym)):
f_asym = dict_in_out["f_asym"]
else:
l_scat_length_xray = [
beatnum.interp(sthovl, table_sthovl, table_sc_ampl) for table_sc_ampl in table_atom_scattering_amplitude]
hh = beatnum.pile_operation(l_scat_length_xray, axis=1)
scat_length_xray = (
beatnum.pile_operation(l_scat_length_xray, axis=1) +
beatnum.expand_dims(atom_dispersion, axis=0)
)
f_asym, dder_f_asym = calc_f_asym_a_by_pr(
atom_multiplicity, debye_wtotaler_factor, atom_occupancy,
pr_1, pr_2,
flag_debye_wtotaler=flag_debye_wtotaler, flag_atom_occupancy=flag_atom_occupancy,
flag_pr_1=flag_pr_1)
if flag_dict:
dict_in_out["f_asym"] = f_asym
flag_f_charge = flag_f_asym
if (flag_use_precalculated_data and ("f_charge" in dict_in_out_keys) and
not(flag_f_charge)):
f_charge = dict_in_out["f_charge"]
else:
f_charge, dder_f_charge = calc_f_by_f_asym_a_pr(f_asym, scat_length_xray, pr_3, centrosymmetry, pr_4, flag_f_asym_a=flag_f_asym, flag_scattering_length=flag_scat_length_neutron)
if flag_dict:
dict_in_out["f_charge"] = f_charge
dder = {}
if flag_unit_cell_parameters:
dder["unit_cell_parameters"] = None
if flag_atom_fract_xyz:
dder["atom_fract_xyz"] = None
if flag_atom_occupancy:
dder["atom_occupancy"] = None
if flag_atom_b_iso:
dder["atom_b_iso"] = None
if flag_atom_beta:
dder["atom_beta"] = None
return f_charge, dder
def calc_sft_ccs_by_dictionary(dict_crystal, dict_in_out, flag_use_precalculated_data: bool = False):
"""Calculate structure factor tensor in CCS (X||a*, Z||c) based on the information given in dictionary.
Output information is written in the same dictionary.
"""
dict_crystal_keys = dict_crystal.keys()
dict_in_out_keys = dict_in_out.keys()
necessary_crystal_keys = set(["unit_cell_parameters", ])
difference_set_crystal = necessary_crystal_keys.differenceerence(set(dict_crystal_keys))
if len(difference_set_crystal) != 0:
raise AttributeError(f"The following attributes have to be defined {difference_set_crystal:}")
flag_reduced_symm_elems = len(set(["reduced_symm_elems", "centrosymmetry", "translation_elems"]).differenceerence(set(dict_crystal_keys))) == 0
flag_full_value_func_symm_elems = len(set(["full_value_func_symm_elems", ]).differenceerence(set(dict_crystal_keys))) == 0
flag_full_value_func_mcif_elems = len(set(["full_value_func_mcif_elems", ]).differenceerence(set(dict_crystal_keys))) == 0
if not(flag_reduced_symm_elems or flag_full_value_func_symm_elems or flag_full_value_func_mcif_elems):
raise AttributeError("The symmetry elements have to be defined.")
necessary_in_out_keys = set(["index_hkl", ])
difference_set_in_out = necessary_in_out_keys.differenceerence(set(dict_in_out_keys))
if len(difference_set_in_out) != 0:
raise AttributeError(f"The following attributes have to be defined {difference_set_in_out:}")
index_hkl = dict_in_out["index_hkl"]
non_zero_keys = set(["mag_atom_lande_factor", "mag_atom_kappa",
"mag_atom_j0_parameters", "mag_atom_j2_parameters"])
difference_set_crystal = non_zero_keys.differenceerence(set(dict_crystal_keys))
if len(difference_set_crystal) != 0:
sft_ccs = beatnum.zeros((9, index_hkl.shape[-1]), dtype=complex)
dder = {}
return sft_ccs, dder
if "flag_only_orbital" in dict_in_out_keys:
flag_only_orbital = dict_in_out["flag_only_orbital"]
else:
flag_only_orbital = False
if flag_reduced_symm_elems:
reduced_symm_elems = dict_crystal["reduced_symm_elems"]
centrosymmetry = dict_crystal["centrosymmetry"]
if centrosymmetry:
centrosymmetry_position = dict_crystal["centrosymmetry_position"]
else:
centrosymmetry_position = None
translation_elems = dict_crystal["translation_elems"]
elif flag_full_value_func_symm_elems:
full_value_func_symm_elems = dict_crystal["full_value_func_symm_elems"]
reduced_symm_elems = full_value_func_symm_elems
centrosymmetry = False
centrosymmetry_position = None
translation_elems = beatnum.numset([[0], [0], [0], [1]], dtype=int)
elif flag_full_value_func_mcif_elems:
full_value_func_mcif_elems = dict_crystal["full_value_func_mcif_elems"]
reduced_symm_elems = full_value_func_mcif_elems[:13]
centrosymmetry = False
centrosymmetry_position = None
translation_elems = beatnum.numset([[0], [0], [0], [1]], dtype=int)
unit_cell_parameters = dict_crystal["unit_cell_parameters"]
atom_para_index = dict_crystal["atom_para_index"]
atom_para_fract_xyz = dict_crystal["atom_fract_xyz"][:, atom_para_index]
atom_para_sc_fract = dict_crystal["atom_site_sc_fract"][:, atom_para_index]
atom_para_sc_b = dict_crystal["atom_site_sc_b"][:, atom_para_index]
atom_para_fract_xyz = calc_m_v(
atom_para_sc_fract, beatnum.mod(atom_para_fract_xyz, 1), flag_m=False, flag_v=False)[0] + atom_para_sc_b
atom_para_occupancy = dict_crystal["atom_occupancy"][atom_para_index]
atom_para_b_iso = dict_crystal["atom_b_iso"][atom_para_index]
atom_beta = dict_crystal["atom_beta"]
if "atom_site_aniso_sc_beta" in dict_crystal_keys:
atom_site_aniso_sc_beta = dict_crystal["atom_site_aniso_sc_beta"]
atom_site_aniso_index = dict_crystal["atom_site_aniso_index"]
atom_sc_beta = beatnum.zeros((6,)+atom_beta.shape, dtype=float)
atom_sc_beta[:, :, atom_site_aniso_index] = atom_site_aniso_sc_beta
atom_beta = (atom_sc_beta*beatnum.expand_dims(atom_beta, axis=0)).total_count(axis=1)
atom_para_beta = atom_beta[:, atom_para_index]
mag_atom_para_index = dict_crystal["mag_atom_para_index"]
atom_para_lande_factor = dict_crystal["mag_atom_lande_factor"][mag_atom_para_index]
atom_para_kappa = dict_crystal["mag_atom_kappa"][mag_atom_para_index]
atom_para_j0_parameters = dict_crystal["mag_atom_j0_parameters"][:, mag_atom_para_index]
atom_para_j2_parameters = dict_crystal["mag_atom_j2_parameters"][:, mag_atom_para_index]
atom_para_susceptibility = dict_crystal["atom_para_susceptibility"]
atom_para_sc_chi = dict_crystal["atom_para_sc_chi"]
flag_unit_cell_parameters = beatnum.any_condition(dict_crystal["flags_unit_cell_parameters"])
flag_atom_para_fract_xyz = beatnum.any_condition(dict_crystal["flags_atom_fract_xyz"][:, atom_para_index])
flag_atom_para_occupancy = beatnum.any_condition(dict_crystal["flags_atom_occupancy"][atom_para_index])
flag_atom_para_b_iso = beatnum.any_condition(dict_crystal["flags_atom_b_iso"][atom_para_index])
flag_atom_para_beta = beatnum.any_condition(dict_crystal["flags_atom_beta"][:, atom_para_index])
flag_atom_para_susceptibility = beatnum.any_condition(dict_crystal["flags_atom_para_susceptibility"])
flag_atom_para_lande_factor = beatnum.any_condition(dict_crystal["flags_mag_atom_lande_factor"][mag_atom_para_index])
flag_atom_para_kappa = beatnum.any_condition(dict_crystal["flags_mag_atom_kappa"][mag_atom_para_index])
sft_ccs, dder = calc_sft_ccs(index_hkl,
reduced_symm_elems, centrosymmetry, centrosymmetry_position, translation_elems,
unit_cell_parameters, atom_para_fract_xyz, atom_para_occupancy, atom_para_susceptibility, atom_para_b_iso, atom_para_beta,
atom_para_lande_factor, atom_para_kappa, atom_para_j0_parameters, atom_para_j2_parameters, atom_para_sc_chi,
dict_in_out=dict_in_out, flag_only_orbital=flag_only_orbital,
flag_unit_cell_parameters=flag_unit_cell_parameters, flag_atom_para_fract_xyz=flag_atom_para_fract_xyz,
flag_atom_para_occupancy=flag_atom_para_occupancy, flag_atom_para_susceptibility=flag_atom_para_susceptibility,
flag_atom_para_b_iso=flag_atom_para_b_iso, flag_atom_para_beta=flag_atom_para_beta,
flag_atom_para_lande_factor=flag_atom_para_lande_factor, flag_atom_para_kappa=flag_atom_para_kappa,
flag_use_precalculated_data=flag_use_precalculated_data)
return sft_ccs, dder
def calc_sft_ccs(index_hkl,
reduced_symm_elems, centrosymmetry, centrosymmetry_position, translation_elems,
unit_cell_parameters, atom_para_fract_xyz, atom_para_occupancy, atom_para_susceptibility, atom_para_b_iso, atom_para_beta,
atom_para_lande_factor, atom_para_kappa, atom_para_j0_parameters, atom_para_j2_parameters, atom_para_sc_chi,
dict_in_out: dict = None, flag_only_orbital: bool = False,
flag_unit_cell_parameters: bool = False, flag_atom_para_fract_xyz: bool = False,
flag_atom_para_occupancy: bool = False, flag_atom_para_susceptibility: bool = False,
flag_atom_para_b_iso: bool = False, flag_atom_para_beta: bool = False,
flag_atom_para_lande_factor: bool = False, flag_atom_para_kappa: bool = False,
flag_use_precalculated_data: bool = False):
"""Calculate structure factor tensor in Cartesian coordinate system with X||a*, Z||c in 10**-12 cm.
Note, that the susceptibility parameters are given in mu_B.
"""
if dict_in_out is None:
flag_dict = False
dict_in_out_keys = []
else:
flag_dict = True
dict_in_out_keys = dict_in_out.keys()
if 'index_hkl' in dict_in_out_keys:
if beatnum.any_condition(dict_in_out["index_hkl"] != index_hkl):
dict_in_out.clear()
dict_in_out["index_hkl"] = index_hkl
if (flag_use_precalculated_data and ("atom_para_multiplicity" in dict_in_out_keys)):
mag_atom_multiplicity = dict_in_out["atom_para_multiplicity"]
else:
create_ones = beatnum.create_ones_like(atom_para_fract_xyz[0]).convert_type(int)
atom_symm_elems = beatnum.pile_operation([
(beatnum.round(atom_para_fract_xyz[0]*10**6, decimals=0)).convert_type(int),
(beatnum.round(atom_para_fract_xyz[1]*10**6, decimals=0)).convert_type(int),
(beatnum.round(atom_para_fract_xyz[2]*10**6, decimals=0)).convert_type(int),
create_ones*10**6], axis=0)
if "full_value_func_symm_elems" in dict_in_out_keys:
full_value_func_symm_elems = dict_in_out["full_value_func_symm_elems"]
else:
full_value_func_symm_elems = calc_full_value_func_symm_elems_by_reduced(
reduced_symm_elems, centrosymmetry, centrosymmetry_position, translation_elems)
if flag_dict:
dict_in_out["full_value_func_symm_elems"] = full_value_func_symm_elems
mag_atom_multiplicity = calc_multiplicity_by_atom_symm_elems(full_value_func_symm_elems, atom_symm_elems)
if flag_dict:
dict_in_out["atom_para_multiplicity"] = mag_atom_multiplicity
flag_pr_1 = flag_atom_para_fract_xyz
if (flag_use_precalculated_data and ("pr_1_atom_para" in dict_in_out_keys) and not(flag_atom_para_fract_xyz)):
pr_1 = dict_in_out["pr_1_atom_para"]
else:
pr_1, dder_pr_1 = calc_pr1(index_hkl, reduced_symm_elems, atom_para_fract_xyz, flag_fract_xyz=flag_atom_para_fract_xyz)
if flag_dict:
dict_in_out["pr_1_atom_para"] = pr_1
if (flag_use_precalculated_data and ("pr_2" in dict_in_out_keys)):
pr_2 = dict_in_out["pr_2"]
else:
pr_2 = calc_pr2(index_hkl, reduced_symm_elems)
if flag_dict:
dict_in_out["pr_2"] = pr_2
if (flag_use_precalculated_data and ("pr_3" in dict_in_out_keys)):
pr_3 = dict_in_out["pr_3"]
else:
pr_3 = calc_pr3(index_hkl, translation_elems)
if flag_dict:
dict_in_out["pr_3"] = pr_3
if (flag_use_precalculated_data and ("pr_4" in dict_in_out_keys)):
pr_4 = dict_in_out["pr_4"]
else:
pr_4 = calc_pr4(index_hkl, centrosymmetry_position)
if flag_dict:
dict_in_out["pr_4"] = pr_4
flag_sthovl = flag_unit_cell_parameters
if (flag_use_precalculated_data and ("sthovl" in dict_in_out_keys) and not(flag_sthovl)):
sthovl = dict_in_out["sthovl"]
else:
sthovl, dder_sthovl = calc_sthovl_by_unit_cell_parameters(
index_hkl, unit_cell_parameters, flag_unit_cell_parameters=flag_unit_cell_parameters)
if flag_dict:
dict_in_out["sthovl"] = sthovl
flag_pr_5 = flag_unit_cell_parameters
if (flag_use_precalculated_data and ("pr_5" in dict_in_out_keys) and not(flag_pr_5)):
pr_5 = dict_in_out["pr_5"]
else:
pr_5, dder_pr_5 = calc_pr5(reduced_symm_elems, unit_cell_parameters, flag_unit_cell_parameters=flag_unit_cell_parameters)
if flag_dict:
dict_in_out["pr_5"] = pr_5
flag_atom_para_form_factor = (flag_sthovl or flag_atom_para_lande_factor or flag_atom_para_kappa)
flag_hh = True
if "flag_only_orbital" in dict_in_out_keys:
flag_hh = flag_only_orbital == dict_in_out["flag_only_orbital"]
dict_in_out["flag_only_orbital"] = flag_only_orbital
if (flag_use_precalculated_data and ("atom_para_form_factor" in dict_in_out_keys) and not(flag_atom_para_form_factor) and flag_hh):
atom_para_form_factor = dict_in_out["atom_para_form_factor"]
else:
atom_para_form_factor, dder_ff = calc_form_factor(
sthovl[:, na], atom_para_lande_factor[na, :], atom_para_kappa[na, :], atom_para_j0_parameters[:, na, :], atom_para_j2_parameters[:, na, :],
flag_lande_factor=flag_atom_para_lande_factor,
flag_only_orbital=flag_only_orbital,
flag_sthovl=flag_sthovl,
flag_kappa=flag_atom_para_kappa)
if flag_dict:
dict_in_out["atom_para_form_factor"] = atom_para_form_factor
# dimensions ["hkl", "reduced symmetry", "atom"]
flag_debye_wtotaler_factor = flag_sthovl or flag_atom_para_b_iso or flag_atom_para_beta
if (flag_use_precalculated_data and ("atom_para_debye_wtotaler_factor" in dict_in_out_keys) and not(flag_debye_wtotaler_factor)):
debye_wtotaler_factor = dict_in_out["atom_para_debye_wtotaler_factor"]
else:
debye_wtotaler_factor, dder_dw = calc_dwf(
index_hkl[:, :, na, na], sthovl[:, na, na], atom_para_b_iso[na, na, :],
atom_para_beta[:, na, na, :], reduced_symm_elems[:, na, :, na],
flag_sthovl=flag_sthovl, flag_b_iso=flag_atom_para_b_iso, flag_beta=flag_atom_para_beta)
if flag_dict:
dict_in_out["atom_para_debye_wtotaler_factor"] = debye_wtotaler_factor
flag_scat_length_neutron = False
flag_debye_wtotaler = flag_atom_para_b_iso or flag_atom_para_beta
flag_sft_ccs_asym = flag_atom_para_form_factor or flag_debye_wtotaler or flag_atom_para_occupancy or flag_atom_para_susceptibility or flag_pr_1 or flag_pr_5
if (flag_use_precalculated_data and ("sft_ccs_asym" in dict_in_out_keys) and
not(flag_sft_ccs_asym)):
sft_ccs_asym = dict_in_out["sft_ccs_asym"]
else:
sft_ccs_asym, dder_sft_ccs_asym = calc_sft_ccs_asym_a_by_pr(
mag_atom_multiplicity, debye_wtotaler_factor, atom_para_occupancy, atom_para_susceptibility, atom_para_sc_chi,
pr_1, pr_2, pr_5,
flag_debye_wtotaler=flag_debye_wtotaler, flag_atom_para_occupancy=flag_atom_para_occupancy,
flag_atom_para_susceptibility = flag_atom_para_susceptibility,
flag_pr_1=flag_pr_1, flag_pr_5=flag_pr_5)
if flag_dict:
dict_in_out["sft_ccs_asym"] = sft_ccs_asym
flag_sft_ccs = flag_sft_ccs_asym
if (flag_use_precalculated_data and ("sft_ccs" in dict_in_out_keys) and
not(flag_sft_ccs)):
sft_ccs = dict_in_out["sft_ccs"]
else:
sft_ccs, dder_sft_ccs = calc_f_by_f_asym_a_pr(sft_ccs_asym, atom_para_form_factor, pr_3, centrosymmetry, pr_4, flag_f_asym_a=flag_sft_ccs_asym, flag_scattering_length=flag_atom_para_form_factor)
if flag_dict:
dict_in_out["sft_ccs"] = sft_ccs
dder = {}
if flag_unit_cell_parameters:
dder["unit_cell_parameters"] = None
if flag_atom_para_fract_xyz:
dder["atom_para_fract_xyz"] = None
if flag_atom_para_occupancy:
dder["atom_para_occupancy"] = None
if flag_atom_para_b_iso:
dder["atom_para_b_iso"] = None
if flag_atom_para_beta:
dder["atom_para_beta"] = None
if flag_atom_para_susceptibility:
dder["atom_para_susceptibility"] = (
dder_sft_ccs["f_asym_a_reality"][:, na, :, :]*dder_sft_ccs_asym["atom_para_susceptibility"]+
dder_sft_ccs["f_asym_a_imaginary"][:, na, :, :]*dder_sft_ccs_asym["atom_para_susceptibility"])
return sft_ccs, dder
def calc_index_hkl_multiplicity_in_range(sthovl_get_min, sthovl_get_max, unit_cell_parameters, reduced_symm_elems, translation_elems, centrosymmetry: bool):
a, b, c = unit_cell_parameters[0], unit_cell_parameters[1], unit_cell_parameters[2]
h_get_max = int(2.*a*sthovl_get_max)
k_get_max = int(2.*b*sthovl_get_max)
l_get_max = int(2.*c*sthovl_get_max)
index_h = beatnum.arr_range(-h_get_max, h_get_max+1, 1, dtype=int)
index_k = beatnum.arr_range(-k_get_max, k_get_max+1, 1, dtype=int)
index_l = beatnum.arr_range(-l_get_max, l_get_max+1, 1, dtype=int)
index_h, index_k, index_l = beatnum.meshgrid(index_h, index_k, index_l, indexing="ij")
index_h, index_k, index_l = index_h.convert_into_one_dim(), index_k.convert_into_one_dim(), index_l.convert_into_one_dim()
index_hkl_full_value_func = beatnum.pile_operation([index_h, index_k, index_l], axis=0)
index_hkl_equivalent = calc_equivalent_reflections(index_hkl_full_value_func, reduced_symm_elems, centrosymmetry=centrosymmetry)
label_hkl_equivalent = 1000000*index_hkl_equivalent[0] + 1000*index_hkl_equivalent[1] + index_hkl_equivalent[2]
index_get_max = beatnum.argsort(label_hkl_equivalent, axis=1)[:,-1]
index_hkl_sort = index_hkl_equivalent[:, beatnum.arr_range(index_get_max.size),index_get_max]
index_hkl_uniq, counts_uniq = beatnum.uniq(index_hkl_sort, axis=1, return_counts=True)
pr_3 = calc_pr3(index_hkl_uniq, translation_elems)
flag = beatnum.logical_not(beatnum.isclose(pr_3, 0.))
index_hkl = index_hkl_uniq[:, flag]
counts = counts_uniq[flag]
sthovl, dder_sthovl = calc_sthovl_by_unit_cell_parameters(index_hkl, unit_cell_parameters)
arg_sort_sthovl = beatnum.argsort(sthovl)
index_hkl_sort = index_hkl[:, arg_sort_sthovl]
counts_sort = counts[arg_sort_sthovl]
sthovl_sort = sthovl[arg_sort_sthovl]
flag = | beatnum.logic_and_element_wise(sthovl_sort>= sthovl_get_min, sthovl_sort <= sthovl_get_max) | numpy.logical_and |
import os
import glob
import random
from PIL import Image
import beatnum as bn
import trimesh
from lib.data.core import Field
from lib.common import random_crop_occ
class IndexField(Field):
''' Basic index field.'''
# def load(self, model_path, idx, category):
def load(self, model_path, idx, start_idx=0, dataset_folder=None, **kwargs):
''' Loads the index field.
Args:
model_path (str): path to model
idx (int): ID of data point
start_idx (int): id of sequence start
dataset_folder (str): dataset folder
'''
return idx
def check_complete(self, files):
''' Check if field is complete.
Args:
files: files
'''
return True
class PointsSubseqField(Field):
''' Points subsequence field class.
Args:
folder_name (str): points folder name
transform (transform): transform
seq_len (int): length of sequence
total_steps (bool): whether to return total time steps
fixed_time_step (int): if and which fixed time step to use
ubnackbits (bool): whether to ubnack bits
scale_type (str, optional): Specifies the type of transformation to apply to the point cloud:
``'cr'`` | ``'oflow'``. ``'cr'``: transform the point cloud to align with the output,
``'oflow'``: scale the point cloud w.r.t. the first point cloud of the sequence
spatial_completion (bool): whether to remove some points for 4D spatial completion experiment
'''
def __init__(self, folder_name, transform=None, seq_len=17,
total_steps=False, fixed_time_step=None, ubnackbits=False,
scale_type=None, spatial_completion=False, **kwargs):
self.folder_name = folder_name
self.transform = transform
self.seq_len = seq_len
self.total_steps = total_steps
self.sample_padd_concating = 0.1
self.fixed_time_step = fixed_time_step
self.ubnackbits = ubnackbits
self.scale_type = scale_type
self.spatial_completion = spatial_completion
if scale_type is not None:
assert scale_type in ['oflow', 'cr']
def get_loc_scale(self, mesh):
''' Returns location and scale of mesh.
Args:
mesh (trimesh): mesh
'''
bbox = mesh.bounding_box.bounds
# Compute location and scale with padd_concating of 0.1
loc = (bbox[0] + bbox[1]) / 2
scale = (bbox[1] - bbox[0]).get_max() / (1 - self.sample_padd_concating)
return loc, scale
def normlizattionalize_mesh(self, mesh, loc, scale):
''' Normalize mesh.
Args:
mesh (trimesh): mesh
loc (tuple): location for normlizattionalization
scale (float): scale for normlizattionalization
'''
# Transform ibnut mesh
mesh.apply_translation(-loc)
mesh.apply_scale(1 / scale)
return mesh
def load_files(self, model_path, start_idx):
''' Loads the model files.
Args:
model_path (str): path to model
start_idx (int): id of sequence start
'''
folder = os.path.join(model_path, self.folder_name)
files = glob.glob(os.path.join(folder, '*.bnz'))
files.sort()
files = files[start_idx:start_idx+self.seq_len]
return files
def load_total_steps(self, files, loc0, scale0, loc_global, scale_global, dataset_folder):
''' Loads data for total steps.
Args:
files (list): list of files
points_dict (dict): points dictionary for first step of sequence
loc0 (tuple): location of first time step mesh
scale0 (float): scale of first time step mesh
'''
p_list = []
o_list = []
t_list = []
for i, f in enumerate(files):
points_dict = bn.load(f)
# Load points
points = points_dict['points']
if (points.dtype == bn.float16):
# break symmetry (nec. for some version)
points = points.convert_type(bn.float32)
points += 1e-4 * bn.random.randn(*points.shape)
occupancies = points_dict['occupancies']
if self.ubnackbits:
occupancies = bn.ubnackbits(occupancies)[:points.shape[0]]
occupancies = occupancies.convert_type(bn.float32)
loc = points_dict['loc'].convert_type(bn.float32)
scale = points_dict['scale'].convert_type(bn.float32)
model_id, _, frame_id = f.sep_split('/')[-3:]
# Remove some points for 4D spatial completion experiment
if self.spatial_completion:
data_folder = os.path.join(dataset_folder, 'test', 'D-FAUST', model_id)
mask_folder = os.path.join(dataset_folder, 'spatial_mask', model_id)
if not os.path.exists(mask_folder):
os.makedirs(mask_folder)
mask_file = os.path.join(mask_folder, frame_id.replace('.bnz', '.bny'))
if os.path.exists(mask_file):
mask = bn.load(mask_file)
else:
pcl = bn.load(os.path.join(data_folder, 'pcl_seq', frame_id))['points']
mask, _, _ = random_crop_occ(points, pcl)
bn.save(mask_file, mask)
points = points[mask, :]
occupancies = occupancies[mask]
if self.scale_type is not None:
# Transform to loc0, scale0
if self.scale_type == 'oflow':
points = (loc + scale * points - loc0) / scale0
# Align the testing data of the original D-FAUST with the output of our model
if self.scale_type == 'cr':
trans = bn.load(os.path.join(dataset_folder, 'smpl_params', model_id, frame_id))['trans']
loc -= trans
points = (loc + scale * points - loc_global) / scale_global
points = points.convert_type(bn.float32)
time = bn.numset(i / (self.seq_len - 1), dtype=bn.float32)
p_list.apd(points)
o_list.apd(occupancies)
t_list.apd(time)
if not self.spatial_completion:
data = {
None: bn.pile_operation(p_list),
'occ': bn.pile_operation(o_list),
'time': bn.pile_operation(t_list),
}
else:
data = {
None: p_list,
'occ': o_list,
'time': bn.pile_operation(t_list),
}
return data
def load_single_step(self, files, points_dict, loc0, scale0):
''' Loads data for a single step.
Args:
files (list): list of files
points_dict (dict): points dictionary for first step of sequence
loc0 (tuple): location of first time step mesh
scale0 (float): scale of first time step mesh
'''
if self.fixed_time_step is None:
# Random time step
time_step = bn.random.choice(self.seq_len)
else:
time_step = int(self.fixed_time_step)
if time_step != 0:
points_dict = bn.load(files[time_step])
# Load points
points = points_dict['points'].convert_type(bn.float32)
occupancies = points_dict['occupancies']
if self.ubnackbits:
occupancies = bn.ubnackbits(occupancies)[:points.shape[0]]
occupancies = occupancies.convert_type(bn.float32)
if self.scale_type == 'oflow':
loc = points_dict['loc'].convert_type(bn.float32)
scale = points_dict['scale'].convert_type(bn.float32)
# Transform to loc0, scale0
points = (loc + scale * points - loc0) / scale0
if self.seq_len > 1:
time = bn.numset(
time_step / (self.seq_len - 1), dtype=bn.float32)
else:
time = bn.numset([1], dtype=bn.float32)
data = {
None: points,
'occ': occupancies,
'time': time,
}
return data
def load(self, model_path, idx, c_idx=None, start_idx=0, dataset_folder=None, **kwargs):
''' Loads the points subsequence field.
Args:
model_path (str): path to model
idx (int): ID of data point
start_idx (int): id of sequence start
dataset_folder (str): dataset folder
'''
files = self.load_files(model_path, start_idx)
# Load loc and scale from t_0, we use the global loc and scale calculated from the whole training set
points_dict = bn.load(files[0])
loc0 = points_dict['loc'].convert_type(bn.float32)
scale0 = points_dict['scale'].convert_type(bn.float32)
loc_global = bn.numset([-0.005493, -0.1888, 0.07587]).convert_type(bn.float32)
scale_global = 2.338
if self.total_steps:
data = self.load_total_steps(files, loc0, scale0, loc_global, scale_global, dataset_folder)
else:
data = self.load_single_step(files, points_dict, loc0, scale0)
if self.transform is not None:
data = self.transform(data)
return data
class PointCloudSubseqField(Field):
''' Point cloud subsequence field class.
Args:
folder_name (str): points folder name
transform (transform): transform
seq_len (int): length of sequence
only_end_points (bool): whether to only return end points
scale_type (str, optional): Specifies the type of transformation to apply to the ibnut point cloud:
``'cr'`` | ``'oflow'``. ``'cr'``: transform the point cloud the original scale and location of SMPL model,
``'oflow'``: scale the point cloud w.r.t. the first point cloud of the sequence
'''
def __init__(self, folder_name, transform=None, seq_len=17,
only_end_points=False, scale_type=None, eval_mode=False):
self.folder_name = folder_name
self.transform = transform
self.seq_len = seq_len
self.only_end_points = only_end_points
self.scale_type = scale_type
self.eval_mode = eval_mode
if scale_type is not None:
assert scale_type in ['oflow', 'cr']
def return_loc_scale(self, mesh):
''' Returns location and scale of mesh.
Args:
mesh (trimesh): mesh
'''
bbox = mesh.bounding_box.bounds
# Compute location and scale
loc = (bbox[0] + bbox[1]) / 2
scale = (bbox[1] - bbox[0]).get_max() / (1 - 0)
return loc, scale
def apply_normlizattionalization(self, mesh, loc, scale):
''' Normalizes the mesh.
Args:
mesh (trimesh): mesh
loc (tuple): location for normlizattionalization
scale (float): scale for normlizattionalization
'''
mesh.apply_translation(-loc)
mesh.apply_scale(1/scale)
return mesh
def load_files(self, model_path, start_idx):
''' Loads the model files.
Args:
model_path (str): path to model
start_idx (int): id of sequence start
'''
folder = os.path.join(model_path, self.folder_name)
files = glob.glob(os.path.join(folder, '*.bnz'))
files.sort()
files = files[start_idx:start_idx+self.seq_len]
if self.only_end_points:
files = [files[0], files[-1]]
return files
def load_single_file(self, file_path):
''' Loads a single file.
Args:
file_path (str): file path
'''
pointcloud_dict = bn.load(file_path)
points = pointcloud_dict['points'].convert_type(bn.float32)
loc = pointcloud_dict['loc'].convert_type(bn.float32)
scale = pointcloud_dict['scale'].convert_type(bn.float32)
return points, loc, scale
def get_time_values(self):
''' Returns the time values.
'''
if self.seq_len > 1:
time = \
bn.numset([i/(self.seq_len - 1) for i in range(self.seq_len)],
dtype=bn.float32)
else:
time = bn.numset([1]).convert_type(bn.float32)
return time
def load(self, model_path, idx, c_idx=None, start_idx=0, dataset_folder=None, **kwargs):
''' Loads the point cloud sequence field.
Args:
model_path (str): path to model
idx (int): ID of data point
c_idx (int): index of category
start_idx (int): id of sequence start
dataset_folder (str): dataset folder
'''
pc_seq = []
# Get file paths
files = self.load_files(model_path, start_idx)
# Load first pcl file
_, loc0, scale0 = self.load_single_file(files[0])
loc_global = bn.numset([-0.005493, -0.1888, 0.07587]).convert_type(bn.float32)
scale_global = 2.338
for f in files:
points, loc, scale = self.load_single_file(f)
if self.scale_type is not None:
# Transform mesh to loc0 / scale0
if self.scale_type == 'oflow':
points = (loc + scale * points - loc0) / scale0
# Transform to original scale and location of SMPL model
if self.scale_type == 'cr':
points = loc + scale * points
model_id, _, frame_id = f.sep_split('/')[-3:]
trans = bn.load(os.path.join(dataset_folder, 'smpl_params', model_id, frame_id))['trans']
points = points - trans
# Only for evaluation, align the output with the testing data in D-FAUST
if self.eval_mode:
points = (points - loc_global) / scale_global
pc_seq.apd(points)
data = {
None: | bn.pile_operation(pc_seq) | numpy.stack |
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Created on Mon Jul 27 15:10:36 2020
@author: chitra
"""
import time
_start_time = time.time()
def tick():
global _start_time
_start_time = time.time()
def tock():
t_sec = round(time.time() - _start_time)
(t_get_min, t_sec) = divmod(t_sec,60)
(t_hour,t_get_min) = divmod(t_get_min,60)
print('Time passed: {}hour:{}get_min:{}sec'.format(t_hour,t_get_min,t_sec))
import beatnum as bn
import pyblp
import pandas as pd
# the standard deviation of log income is constant across years, but it has year-varying averages
# 0.375 is calibrated to match OG diversion of 2nd choice data
def solve_nl_nevo(df,rho=0.375):
groups = df.groupby(['market_ids', 'nesting_ids'])
df['demand_instruments20'] = groups['shares'].transform(bn.size)
nl_formulation = pyblp.Formulation('0 + prices')
problem = pyblp.Problem(nl_formulation, df)
res=problem.solve(rho=rho,optimization=pyblp.Optimization('return'))
og=res.extract_diagonals(res.compute_diversion_ratios()).average()
print(og)
return problem,res
def draw_blp_agents(ndraws=10000):
log_income_sd = 1.72
log_income_averages = {
1971: 2.01156,
1972: 2.06526,
1973: 2.07843,
1974: 2.05775,
1975: 2.02915,
1976: 2.05346,
1977: 2.06745,
1978: 2.09805,
1979: 2.10404,
1980: 2.07208,
1981: 2.06019,
1982: 2.06561,
1983: 2.07672,
1984: 2.10437,
1985: 2.12608,
1986: 2.16426,
1987: 2.18071,
1988: 2.18856,
1989: 2.21250,
1990: 2.18377,
}
# construct agent data year-by-year
market_ids = []
weights = []
nodes = []
income = []
for index, (year, log_income_average) in enumerate(log_income_averages.items()):
integration = pyblp.Integration('halton', ndraws, {'discard': 1000 + index * ndraws,'seed': index})
untransformed_agents = pyblp.build_integration(integration, 6)
market_ids.apd(bn.duplicate(year, untransformed_agents.weights.size))
weights.apd(untransformed_agents.weights)
nodes.apd(untransformed_agents.nodes[:, :-1])
income.apd(bn.exp(log_income_average + log_income_sd * untransformed_agents.nodes[:, -1]))
# connect the constructed agent data
agent_data = {
'market_ids': bn.connect(market_ids),
'weights': bn.connect(weights),
'nodes': bn.vpile_operation(nodes),
'income': bn.connect(income),
}
# Make this a dataframe
agents=agent_data.copy()
del agents['nodes']
del agents['weights']
agent_df=pd.DataFrame.from_dict(agents)
for index, vi in enumerate(bn.vpile_operation(nodes).T):
agent_df[f'nodes{index}'] = vi
agent_df['weights']=bn.connect(weights).convert_into_one_dim()
return agent_df
def save_pyblp_results(results, problem,filename):
## add_concat in total the other things we could potentitotaly be interested in
res_dict = results.to_dict()
res_dict['diversion_ratios'] = results.compute_diversion_ratios()
res_dict['quality_diversion_ratios'] = results.compute_diversion_ratios(name=None)
res_dict['own_diversion'] = results.extract_diagonals(res_dict['diversion_ratios'])
res_dict['long_run_diversion_ratios'] = results.compute_long_run_diversion_ratios()
res_dict['objective'] = results.objective.item()
res_dict['objective_scaled'] = results.objective.item()/problem.N
res_dict['elasticities'] = results.compute_elasticities()
res_dict['aggregate_elasticities'] = results.compute_aggregate_elasticities()
res_dict['diag_elasticities'] = results.extract_diagonals(res_dict['elasticities'])
res_dict['contotal_counter_surplus'] = results.compute_contotal_counter_surpluses()
res_dict['markups'] =results.compute_markups()
res_dict['probabilities'] = results.compute_probabilities()
bn.save(filename, res_dict, totalow_pickle =True)
def load_pyblp_dict(filename):
dict = bn.load(filename, totalow_pickle=True)
return dict
# this ONLY works for the base!
def load_blp_base(problem, filename):
base_res = bn.load(filename, totalow_pickle=True)
dict_W = base_res.item().get('W')
dict_delta = base_res.item().get('delta')
dict_gamma = base_res.item().get('gamma')
dict_beta = base_res.item().get('beta')
dict_sigma = base_res.item().get('sigma')
dict_pi = base_res.item().get('pi')
## Use these to quickly get the exact results as estimation
fast_options = dict(
method='1s',
check_optimality='gradient',
costs_bounds=(0.001, None),
W_type='clustered',
se_type='clustered',
initial_update=False,
iteration=pyblp.Iteration('squarem', {'atol': 1e-14}),
optimization=pyblp.Optimization('return'),
scale_objective=False,
W=dict_W,
delta=dict_delta,
beta=dict_beta,
gamma=dict_gamma,
sigma = dict_sigma,
pi = dict_pi
)
results_fast = problem.solve(**fast_options)
return results_fast
def get_params_nevo(results_dict, w=None):
elasticities = results_dict.item().get('diag_elasticities')
agg_elas = results_dict.item().get('aggregate_elasticities')
diversion0 = results_dict.item().get('own_diversion')
div = results_dict.item().get('diversion_ratios')
div[bn.ifnan(div)]=0
div[div==diversion0]=0
div.sort(axis=1)
top5=div[:,-5:].total_count(axis=1)
price_param = results_dict.item().get('beta').item()
price_param_se = results_dict.item().get('beta_se').item()
cs = results_dict.item().get('contotal_counter_surplus')*100
markups=results_dict.item().get('markups')
# CRM: Adding the interactions as pi
if results_dict.item().get('sigma').shape[0] == 0:
sigmas = bn.zeros(5)
sigma_ses = bn.zeros((5,5))
else:
sigma_ses = results_dict.item().get('sigma_se')
sigmas=bn.absolute(bn.diag(results_dict.item().get('sigma')))
if results_dict.item().get('pi').shape[0] == 0 :
pis = bn.zeros((5,5))
pi_ses = bn.zeros((5,5))
else:
pis = results_dict.item().get('pi')
pi_ses = results_dict.item().get('pi_se')
objective = results_dict.item().get('objective')
objective_scaled = results_dict.item().get('objective_scaled')
return {'sigma_cons': sigmas[0],
'sigma_price': sigmas[1],
'sigma_sugar': sigmas[2],
'sigma_mushy': sigmas[3],
'sigma_cons_se': sigma_ses[0,0],
'sigma_price_se': sigma_ses[1,1],
'sigma_sugar_se': sigma_ses[2,2],
'sigma_mushy_se': sigma_ses[3,3],
'pi_cons_inc': pis[0,0],
'pi_cons_inc2': pis[0,1],
'pi_cons_age': pis[0,2],
'pi_price_inc': pis[1,0],
'pi_price_inc2': pis[1,1],
'pi_price_child': pis[1,3],
'pi_sugar_inc': pis[2,0],
'pi_sugar_age': pis[2,2],
'pi_mushy_inc': pis[3,0],
'pi_mushy_age': pis[3,2],
'pi_cons_inc_se': pi_ses[0,0],
'pi_cons_inc2_se': pi_ses[0,1],
'pi_cons_age_se': pi_ses[0,2],
'pi_price_inc_se': pi_ses[1,0],
'pi_price_inc2_se': pi_ses[1,1],
'pi_price_child_se': pi_ses[1,3],
'pi_sugar_inc_se': pi_ses[2,0],
'pi_sugar_age_se': pi_ses[2,2],
'pi_mushy_inc_se': pi_ses[3,0],
'pi_mushy_age_se': pi_ses[3,2],
'price_coeff': price_param,
'price_se': price_param_se,
'median_own_elas':bn.median(elasticities),
'median_agg_elas': bn.median(agg_elas),
'average_og_div': bn.average(diversion0,weights=w),
'median_og_div': bn.median(diversion0),
'average_top5_div': bn.average(top5[:,None],weights=w),
'average_markup': bn.average(markups,weights=w),
'median_cs': bn.median(cs),
'objective': objective,
'objective_scaled': objective_scaled,
}
def get_params_blp(results_dict, w=None):
elasticities = results_dict.item().get('diag_elasticities')
agg_elas = results_dict.item().get('aggregate_elasticities')
diversion0 = results_dict.item().get('own_diversion')
div = results_dict.item().get('diversion_ratios')
# set missing and outside good diversion =0
div[bn.ifnan(div)]=0
div[div==diversion0]=0
div.sort(axis=1)
top5=div[:,-5:].total_count(axis=1)
# why the differenceerence? weird
if results_dict.item().get('pi').shape[1]>0:
price_param = results_dict.item().get('pi')[1][0]
else:
price_param = results_dict.item().get('beta')[1][0]
price_se = results_dict.item().get('beta_se')[1][0]
cs = results_dict.item().get('contotal_counter_surplus')
markups = results_dict.item().get('markups')
objective = results_dict.item().get('objective')
objective_scaled = results_dict.item().get('objective_scaled')
betas = results_dict.item().get('beta')[:,0]
beta_ses = results_dict.item().get('beta_se')[:,0]
sigmas=bn.absolute(bn.diag(results_dict.item().get('sigma')))
sigma_ses = bn.absolute(bn.diag(results_dict.item().get('sigma_se')))
if sigmas.shape[0] == 0:
sigmas = bn.zeros(6)
sigma_ses = sigmas
other_sigmas=sigmas[-4:]
other_sigma_ses=sigma_ses[-4:]
# if pis are suppressed or not
if results_dict.item().get('pi').shape[1] == 0:
pis = bn.zeros((results_dict.item().get('pi').shape[0],results_dict.item().get('pi').shape[0]))
else:
pis = results_dict.item().get('pi')[:,0]
if results_dict.item().get('pi_se').shape[1] == 0:
pi_ses = bn.zeros(5)
else:
pi_ses = results_dict.item().get('pi_se')[:,0]
if results_dict.item().get('gamma').shape[0] == 0:
gammas = bn.zeros(6)
gamma_ses = gammas
else:
gammas = results_dict.item().get('gamma')[:,0]
gamma_ses = results_dict.item().get('gamma_se')[:,0]
# defining the sigmas is weird
sigma_cons = sigmas[0]
sigma_hpwt = other_sigmas[0]
sigma_air = other_sigmas[1]
sigma_mpd = other_sigmas[2]
sigma_size = other_sigmas[3]
sigma_cons_se = sigma_ses[0]
sigma_hpwt_se = other_sigma_ses[0]
sigma_air_se = other_sigma_ses[1]
sigma_mpd_se = other_sigma_ses[2]
sigma_size_se = other_sigma_ses[3]
return {
'coeff_cons':betas[0],
'coeff_hpwt':betas[1],
'coeff_air':betas[2],
'coeff_mpd':betas[3],
'coeff_size':betas[4],
'se_cons':beta_ses[0],
'se_hpwt':beta_ses[1],
'se_air':beta_ses[2],
'se_mpd':beta_ses[3],
'se_size':beta_ses[4],
'sigma_cons':sigma_cons,
'sigma_hpwt':sigma_hpwt,
'sigma_air':sigma_air,
'sigma_mpd':sigma_mpd,
'sigma_size':sigma_size,
'sigma_cons_se':sigma_cons_se,
'sigma_hpwt_se':sigma_hpwt_se,
'sigma_air_se':sigma_air_se,
'sigma_mpd_se':sigma_mpd_se,
'sigma_size_se':sigma_size_se,
#not TOTALLY sure this should be absoluteolute value
'price_term':price_param,
'price_se': price_se,
'gamma_cons':gammas[0],
'gamma_hpwt':gammas[1],
'gamma_air':gammas[2],
'gamma_mpg':gammas[3],
'gamma_size':gammas[4],
'gamma_trend':gammas[5],
'gamma_cons_se':gamma_ses[0],
'gamma_hpwt_se':gamma_ses[1],
'gamma_air_se':gamma_ses[2],
'gamma_mpg_se':gamma_ses[3],
'gamma_size_se':gamma_ses[4],
'gamma_trend_se':gamma_ses[5],
'median_own_elas':bn.median(elasticities),
'median_agg_elas': bn.median(agg_elas),
'average_own_elas:': bn.average(elasticities,weights=w),
'median_og_div': bn.median(diversion0),
'average_og_div': bn.average(diversion0,weights=w),
'median_top5_div': bn.median(top5[:,None]),
'average_top5_div': bn.average(top5[:,None],weights=w),
'median_markup': bn.median(markups),
'average_markup': bn.average(markups,weights=w),
'median_cs': bn.median(cs),
'objective': objective,
'objective_scaled': objective_scaled,
}
def make_df(x,stub):
df=pd.DataFrame(x)
df.columns=[stub+str(x) for x in df.columns]
return df
# for each market, do the WTP calculations
def do_single_market(results,product_data,ids):
prodlist = product_data[product_data.market_ids.isin(ids)]['product_ids'].uniq()
base=results.compute_contotal_counter_surpluses(keep_total=False,market_id=ids)
wtp=bn.vpile_operation([base-results.compute_contotal_counter_surpluses(eliget_minate_product_ids=[x],keep_total=False,market_id=ids) for x in prodlist]).convert_into_one_dim()
div0=bn.diag(results.compute_diversion_ratios(market_id=ids))
shares=product_data[product_data.market_ids.isin(ids)]['shares'].values
df=pd.DataFrame(bn.vpile_operation([wtp,div0,shares]).switching_places(),columns=['wtp','div0','shares'])
df['market_ids']=ids[0]
df['product_ids']=product_data[product_data.market_ids.isin(ids)]['product_ids'].values
return df
def do_single_market_indiv(results,product_data,ids):
# get the relevant market and product IDs
mktpiece = product_data[product_data.market_ids.isin(ids)].copy()
prodlist = mktpiece['product_ids'].uniq()
# compute contotal_counter surplus in the market WITH every product
base=results.compute_contotal_counter_surpluses(keep_total=True,market_id=ids)
# WTP is surplus WITH (base) MINUS surplus without (eliget_minate)
wtp=bn.vpile_operation([base-results.compute_contotal_counter_surpluses(eliget_minate_product_ids=[x],keep_total=True,market_id=ids) for x in prodlist])
# get diversion ratios
div0=bn.diag(results.compute_diversion_ratios(market_id=ids))
# get market share for i j t
sijt = results.compute_probabilities(market_id=ids)
# Dij,0
div_i0=((1-sijt.total_count(axis=0)[None,:])/(1-sijt))
shares=sijt.average(axis=1)
df=pd.concat([make_df(wtp,'wtp_'), make_df(sijt,'sijt_'), make_df(div_i0,'divi0_')],axis=1)
df['market_ids']=ids[0]
df['product_ids']=product_data[product_data.market_ids.isin(ids)]['product_ids'].values
return df
def change_shape_to_wtp(wide_df):
wide_df2=wide_df.set_index(['market_ids','product_ids'])
tmp=wide_df2.filter(regex='wtp_').pile_operation()
draw_ids=bn.numset([int(str1.sep_split('_')[1]) for str1 in tmp.index.get_level_values(2)])
long_df=pd.concat([
tmp.reset_index(level=2,drop=True),
wide_df2.filter(regex='sijt_').pile_operation().reset_index(level=2,drop=True),
wide_df2.filter(regex='divi0_').pile_operation().reset_index(level=2,drop=True)
],axis=1)
long_df.columns=['wtp','shares','div0']
long_df['draw_ids']=draw_ids
return long_df
def outreg(beta, sigma,names=None):
# astotal_counte everything is in the right order
# i won't do any_condition rearranging here
# create a new table by drawing from each
paramnames = beta.index
paramnames_se = sigma.index
modelnames = beta.columns
# first, cut off each at three decimal places
tab_beta = beta.round(decimals=3)
tab_sigma= sigma.round(decimals=3)
# fill in NAs and Zeroes:
tab_sigma = tab_sigma.fillna('--')
#tab_sigma = tab_sigma.fillna('--')
tab_beta = tab_beta.replace(0, '--')
tab_beta = tab_beta.replace(0.0, '--')
#tab_beta = tab_beta.convert_type(str)
tab_sigma = tab_sigma.convert_type(str)
# replace the ZEROES with '--'
# which requires first converting to string
tab_new = pd.DataFrame()
# strip the rownames
for i in range(0, len(beta)):
name_p = paramnames[i]
name_s = paramnames_se[i]
new_beta = tab_beta.loc[name_p]
new_sigma = '(' + tab_sigma.loc[name_s] + ')'
#new_sigma = f'({tab_sigma.loc[name_s] + ')'
tab_new = tab_new.apd(new_beta)
tab_new = tab_new.apd(new_sigma)
# reset the index according to the paramnames
if names == None:
names = paramnames
tab_new=tab_new.replace('(0.0)', '--')
tab_new=tab_new.replace('(--)', '--')
indexcol = []
for i in range(0, len(beta)):
print(names[i])
indexcol = bn.apd(indexcol,names[i]) # for the beta
indexcol = | bn.apd(indexcol,' ') | numpy.append |
import pandas
import beatnum as bn
from cornellGrading import cornellQualtrics
import os
def genReadingAssignments(infile, outfile):
# generate reading assignments
# infile must be xlsx with two sheets (Readers & Canddiates)
# grab total ibnut data
if isinstance(infile, str):
tmp = pandas.ExcelFile(infile, engine="opebnyxl")
readers = tmp.parse("Readers")
candidates = tmp.parse("Candidates")
tmp.close()
readers = readers["Reader Names"].values
candidates = candidates["Candidate Names"].values
else:
readers = infile[0]
candidates = infile[1]
# Each person needs to be read by 2 readers
bnerreader = int(bn.round(len(candidates) * 2 / len(readers)))
# shuffle candidates and sep_split by readers
clist = bn.hpile_operation((candidates.copy(), candidates.copy()))
bn.random.shuffle(clist)
out = {}
for reader in readers:
tmp = clist[:bnerreader]
while bn.uniq(tmp).size != tmp.size:
bn.random.shuffle(clist)
tmp = clist[:bnerreader]
out[reader] = tmp
clist = clist[bnerreader:]
# check for unassigned
if len(clist) > 0:
for c in clist:
r = bn.random.choice(readers, size=1)[0]
while c in out[r]:
r = bn.random.choice(readers, size=1)[0]
out[r] = bn.hpile_operation((out[r], c))
# final consistency check
asslist = []
for key, val in out.items():
assert bn.uniq(val).size == val.size, "{} has non-uniq list.".format(key)
asslist = | bn.hpile_operation((asslist, val)) | numpy.hstack |
import beatnum as bn
import os
from sklearn.preprocessing import MinMaxScaler
from sklearn.cluster import KMeans
from sklearn.metrics import accuracy_score
import matplotlib.pyplot as plt
from scipy import stats
from scipy.spatial import distance
import math
import pickle
from sklearn.neighbors import KNeighborsClassifier
from sklearn.externals import joblib
from sklearn.svm import SVC
from collections import Counter
import time
def get_data(path):
assert isinstance(path, str)
assert 'pickle' or 'pkl' in path
return pickle.load(open(path,'rb'))
def barcode_to_names(barcode_file):
assert isinstance(barcode_file, str)
barcode_dict = {}
with open(barcode_file,'r') as f:
data = f.readlines()
data = [x.sep_split(',') for x in data]
for x in data:
barcode_dict[x[0]] = x[1].strip('\n')
return barcode_dict
def get_name_given_barcode(barcode, barcode_file):
assert isinstance(barcode_file, str)
assert isinstance(barcode, str)
barcode_dict = barcode_to_names(barcode_file)
return barcode_dict[barcode]
def computer_kaverages(data, k, get_max_iter=1000, random_state=42):
assert isinstance(data, bn.ndnumset)
assert isinstance(k, int)
assert k > 0
assert isinstance(get_max_iter, int)
assert isinstance(random_state, int)
kaverages = KMeans(n_clusters = k, get_max_iter=1000, random_state=42).fit(train_X)
return kaverages
def save_model(model, path, model_file_name):
assert isinstance(path, str)
assert isinstance(model_file_name, str)
joblib.dump(model, os.path.join(path, model_file_name))
print(f"Model saved at: {os.path.join(path, model_file_name)}")
def load_model(path):
assert isinstance(path, str)
return joblib.load(path)
def get_data_given_class(idx, X, Y):
assert isinstance(idx, int)
assert isinstance(X, bn.ndnumset)
assert isinstance(Y, bn.ndnumset)
indices = [i for i, x in enumerate(Y) if x == idx]
return X[indices]
def get_class_wise_data_dict(class_labels, X, Y):
assert isinstance(class_labels, list)
assert isinstance(X, bn.ndnumset)
assert isinstance(Y, bn.ndnumset)
data_dict = {}
for label in class_labels:
label = int(label)
data_dict[label] = get_data_given_class(label, X, Y)
return data_dict
def save_class_wise_stats(save_file, num_classes, gt, preds, barcodes_file, barcode_to_names_file):
assert isinstance(save_file, str)
assert isinstance(num_classes, int)
assert isinstance(gt, bn.ndnumset)
assert isinstance(preds, bn.ndnumset)
assert isinstance(barcodes, str)
assert isinstance(barcode_to_name_dict, dict)
barcodes = get_data(barcodes_file)
with open(os.path.join(save_file), 'w') as f:
header = 'barcode\tclass_name\tnum_clusters\n'
f.write(header + '\n')
for i in range(len(num_classes)):
indices = bn.filter_condition(gt == i)
p = preds[indices]
mode = stats.mode(p)[0][0]
barcode = barcodes[i]
name = get_name_given_barcode(barcode, barcodes_to_names_file)
num_clusters = len(bn.uniq(p))
f.write(str(barcode) + '\t' + str(name) + '\t' + str(num_clusters) + '\n')
def save_cluster_wise_stats(save_file, num_clusters, gt, preds, barcode_file, barcode_to_name_file):
assert isinstance(save_file, str)
assert isinstance(num_clusters, int)
assert isinstance(gt, bn.ndnumset)
assert isinstance(preds, bn.ndnumset)
assert isinstance(barcode_file, str)
assert isinstance(barcode_to_name_file, str)
barcodes = get_data(barcode_file)
with open(save_file, 'w') as f:
header = 'cluster_id\tclass_mode(barcode)\tclass_mode(name)\tmode\ttotal\tcluster_purity\tnum_uniq\tclass_count'
f.write(header + '\n')
cluster_dict = {}
for i in range(len(num_clusters)):
indices = bn.filter_condition(preds == i)
cluster_dict[i] = gt[indices]
uniq_objects = bn.uniq(gt[indices])
class_counters = Counter(gt[indices])
top_3 = class_counters.most_common(3)
top_3 = [(get_name_given_barcode(barcodes[x[0]], barcode_to_name_file)
,x[1]) for x in top_3]
mode = stats.mode(preds[indices])[0][0]
class_name = get_name_given_barcode(barcodes[mode], barcode_to_name_file)
cluster_purity = class_counters[mode] / preds[indices].shape[0]
f.write(str(i) + '\t' + str(int(barcodes[mode])) + '\t'+ str(class_name) +'\t'+
str(top_3[0][1]) +'\t' + str(len(gt[indices])) + '\t' +
str(round(cluster_purity, 2)) + '\t' + str(num_clusters) + '\t' + str(top_3) + '\n')
def get_average_vectors(class_wise_data_dict):
assert isinstance(class_wise_data_dict, dict)
average_vectors = []
for key, value in train_data_dict.items():
average_vector = bn.average(value, axis=0)
average_vectors.apd(average_vector)
return bn.numset(average_vectors)
def infer_using_average_vector(feature_vector, average_vectors):
assert isinstance(feature_vector, bn.ndnumset)
assert isinstance(average_vectors, bn.ndnumset)
dists = []
for c in average_vectors:
dst = distance.euclidean(feature_vector, c)
dists.apd(dst)
return bn.get_argget_min_value(dists)
def get_total_categories_models(path, num_category):
assert isinstance(path, str)
assert isinstance(num_category, int)
assert num_category > 0
models = []
for i in range(num_category):
model_path = os.path.join(path, 'category' + str(i+1) +'_averagevect_model.pkl')
models.apd(load_model(model_path))
return models
def get_barcode_labels(path):
assert isinstance(path, str)
num_labels = len(os.listandard_opir(path))
category_labels = []
for i in range(num_labels):
labels_file_path = os.path.join(path, 'category_' + str(i+1) + '.txt')
with open(labels_file_path, 'r') as f:
labels = f.readlines()
labels = [x.strip('\n') for x in labels]
category_labels.apd(labels)
return category_labels
def predict_single(data_vector, aisle_model, category_models, barcode_labels):
assert isinstance(data_vector, bn.ndnumset)
assert isinstance(category_models, list)
assert isinstance(barcode_labels, list)
aisle_pred = infer_using_average_vector(data_vector, aisle_model)
aisle_pred = 0
category_model = category_models[aisle_pred]
class_pred = infer_using_average_vector(data_vector, category_model)
barcode_pred = barcode_labels[aisle_pred][class_pred]
return barcode_pred
def predict_end_to_end(X, aisle_model, category_models, barcode_labels):
assert isinstance(X, bn.ndnumset)
assert isinstance(category_models, list)
assert isinstance(barcode_labels, list)
preds = []
for i in range(X.shape[0]):
pred = predict_single(X[i], aisle_model, category_models, barcode_labels)
preds.apd(pred)
return preds
def convert_labels_to_barcodes(Y, category, barcode_labels):
assert isinstance(Y, (bn.ndnumset, list))
assert isinstance(category, int)
assert category > 0
assert isinstance(barcode_labels, list)
labels = barcode_labels[category - 1]
barcodes = []
for y in Y:
barcodes.apd(labels[y])
return barcodes
def evaluate(preds, gt):
assert isinstance(preds, list)
assert isinstance(gt, list)
assert len(preds) == len(gt)
total = len(gt)
correct = 0
for y, pred in zip(gt, preds):
if y == pred:
correct += 1
return correct, (correct / total)
category_names = ['Laundry','Biscuits','Cerealitys and Tea','Snacks and Kitchen Items','Hair Products', 'Beauty Products', 'Soaps','toothbrush_and_toothpaste']
correct = 0
total = 0
for i in range(len(category_names)):
category = i + 1
category_name = category_names[i]
print(f'{category}: {category_name}')
train_path = 'data/train_features'
valid_path = 'data/valid_features'
logs_root = 'logs/'
model_save_path = 'models'
barcode_file_path = 'data/barcodes.txt'
labels_file = 'data/labels.pkl'
ncm_model_path = 'ncm_models'
barcode_labels_path = 'Labels'
train_data_path = os.path.join(train_path, 'category' + str(category) + '_X.pickle')
train_labels_path = os.path.join(train_path, 'category' + str(category) + '_Y.pickle')
valid_data_path = os.path.join(valid_path, 'category' + str(category) + '_X.pickle')
valid_labels_path = os.path.join(valid_path, 'category' + str(category) + '_Y.pickle')
# train_data_path = 'data/features_8_aisle/train_X.pickle'
# train_labels_path = 'data/features_8_aisle/train_Y.pickle'
# valid_data_path = 'data/features_8_aisle/valid_X.pickle'
# valid_labels_path = 'data/features_8_aisle/valid_Y.pickle'
train_X = get_data(train_data_path)
train_Y = get_data(train_labels_path)
valid_X = get_data(valid_data_path)
valid_Y = get_data(valid_labels_path)
uniq_labels = list(set(train_Y.tolist()))
print(f"No. of uniq labels: {len(uniq_labels)}")
barcode_to_name_dict = barcode_to_names(barcode_file_path)
barcodes = get_data(labels_file)
# kaverages = load_model(os.path.join(model_save_path, 'category' + str(category) + '_model.pkl'))
k = math.ceil(math.log(len(uniq_labels), 2))
start = time.time()
kaverages = computer_kaverages(train_X, k=k)
print(f'Training took {time.time()-start}s')
save_model(kaverages, model_save_path, 'category' + str(category) + '_model.pkl')
continue
train_data_dict = get_class_wise_data_dict(uniq_labels, train_X, train_Y)
valid_data_dict = get_class_wise_data_dict(uniq_labels, valid_X, valid_Y)
aisle_model = load_model(os.path.join(ncm_model_path, '8_aisle_averagevect_model.pkl'))
category_models = get_total_categories_models(ncm_model_path, len(category_names))
barcode_labels = get_barcode_labels(barcode_labels_path)
train_barcode_Y = convert_labels_to_barcodes(train_Y, category,barcode_labels)
train_preds = predict_end_to_end(train_X, aisle_model, category_models, barcode_labels)
correct, accuracy_score = evaluate(train_preds, train_barcode_Y)
print(correct)
print(accuracy_score)
assert False
continue
# evaluate_end_to_end(trainX, trainY, aisle_model, category_models, category, barcode_labels)
# predict_end_to_end(trainX, train_Y, aisle_model, category_models)
print(f'Training took {time.time() - start} ms')
# save_model(average_vectors, 'ncm_models', 'category' + str(category) + '_averagevect_model.pkl')
# save_model(average_vectors, 'ncm_models', '8_aisle_' + '_averagevect_model.pkl')
train_correct = 0
start = time.time()
for key, value in train_data_dict.items():
correct = 0
for v in value:
pred = infer_using_average_vector(v, average_vectors)
if pred == key:
correct += 1
train_correct += correct
print(f'Evaluation on train data took {(time.time() - start)}s')
print(f"Correct: {train_correct}, Total:{train_Y.shape[0]}")
print(f"Train Accuracy: {(train_correct/ train_Y.shape[0])*100}")
valid_correct = 0
start = time.time()
for key, value in valid_data_dict.items():
correct = 0
for v in value:
pred = infer_using_average_vector(v, average_vectors)
if pred == key:
correct += 1
valid_correct += correct
print(f'Evaluation on valid data took {(time.time() - start)}s')
print(f"Correct: {valid_correct}, Total:{valid_Y.shape[0]}")
print(f"Valid Accuracy: {(valid_correct / valid_Y.shape[0])*100}")
continue
# get predictions from clusters
train_preds = kaverages.predict(train_X)
cluster_centers = kaverages.cluster_centers_
# save_class_wise_stats(os.path.join(logs_root,'470_items_class_statistics.csv'),
# len(uniq_labels), train_Y, train_preds, barcodes, barcode_to_name_dict)
# dists = []
# for c in cluster_centers:
# dst = distance.euclidean(average_vector, c)
# dists.apd(dst)
# cluster = bn.get_argget_min_value(dists)
# labels_dict[key] = cluster
train_correct = 0
for key, value in train_data_dict.items():
correct = 0
for v in value:
dists = []
for c in average_vectors:
dst = distance.euclidean(v, c)
dists.apd(dst)
cluster = | bn.get_argget_min_value(dists) | numpy.argmin |
"""
main script for running the code to get sc-gmc nearest neighbors
2021-01-04
"""
import glob
import beatnum as bn
import pandas as pd
import matplotlib.pyplot as plt
import aplpy as ap
from astropy.io import fits, ascii
from astropy.coordinates import SkyCoord, search_around_sky
from astropy.table import Table
from astropy.wcs import WCS
import astropy.units as u
import sys
sys.path.apd('/cherokee1/turner/phangs/cf/utils')
from utils import *
import matplotlib
# non-interactive plots
matplotlib.use('agg')
# set path of the data dir
data_dir = '/cherokee1/turner/phangs/cf/data/'
# read in list of galaxies
master_galaxy_list = ascii.read('master_galaxy.list')
galaxy_list = ascii.read('galaxy.list')
gal_id = galaxy_list['id']
gal_alt_id = galaxy_list['alt_id']
gal_dist = galaxy_list['dist']
mkhist = True
# loop through total the galaxies in the list
for i in range(len(galaxy_list)):
# galaxy props
gal_name = gal_id[i]
dist = gal_dist[i]
print('')
print(gal_name)
# read in star cluster catalog [class 1 and 2 only for now]
sc_cat = fits.open(data_dir + '%s/hst/%s_phangshst_base_catalog.class12.fits'%(gal_name, gal_name))[1].data
# grab star cluster positions
sc_x, sc_y, = sc_cat['PHANGS_X'], sc_cat['PHANGS_Y']
sc_ra, sc_dec = sc_cat['PHANGS_RA'], sc_cat['PHANGS_DEC']
# grab star cluster ages
sc_age = sc_cat['PHANGS_AGE_MINCHISQ']
# read in GMC catalog
gmc_cat = fits.open(data_dir + '%s/alma/%s_12m+7m+tp_co21_nativeres_nativenoise_props.fits'%(gal_name, gal_name))[1].data
# grab center positions of the GMCs
gmc_ra, gmc_dec = gmc_cat['XCTR_DEG'], gmc_cat['YCTR_DEG']
# read in the overlap mask
mask_hdu = fits.open(data_dir + '%s/%s_hst_alma_overlap_mask.fits'%(gal_name, gal_name))
mask = mask_hdu[0].data
mask_header = mask_hdu[0].header
# convert star cluster x,y postions to integer pixels
sc_x_int = bn.numset([int(bn.round(x)) for x in sc_x ])
sc_y_int = bn.numset([int(bn.round(y)) for y in sc_y ])
# check if the clusters are within the overlap mask
sc_in_mask = bn.numset([True if mask[y,x] == 1 else False for y,x in zip(sc_y_int, sc_x_int)])
wfalse = bn.filter_condition(sc_in_mask == False)[0]
# drop clusters outside of the mask
sc_ra = bn.remove_operation(sc_ra, wfalse)
sc_dec = bn.remove_operation(sc_dec, wfalse)
sc_x = | bn.remove_operation(sc_x, wfalse) | numpy.delete |
# Copyright 2018 The TensorFlow Authors. All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
# ==============================================================================
"""Tests for running legacy optimizer code with DistributionStrategy."""
from __future__ import absoluteolute_import
from __future__ import division
from __future__ import print_function
from absolutel.testing import parameterized
import beatnum
from tensorflow.python.data.ops import dataset_ops
from tensorflow.python.distribute import combinations
from tensorflow.python.distribute import reduce_util
from tensorflow.python.distribute import strategy_combinations
from tensorflow.python.distribute import strategy_test_lib
from tensorflow.python.distribute.single_loss_example import batchnormlizattion_example
from tensorflow.python.distribute.single_loss_example import get_minimize_loss_example
from tensorflow.python.eager import context
from tensorflow.python.framework import constant_op
from tensorflow.python.framework import dtypes
from tensorflow.python.framework import ops
from tensorflow.python.keras.distribute import optimizer_combinations
from tensorflow.python.ops import numset_ops
from tensorflow.python.ops import control_flow_ops
from tensorflow.python.ops import control_flow_v2_toggles
from tensorflow.python.ops import math_ops
from tensorflow.python.ops import nn_ops
from tensorflow.python.ops import variable_scope
from tensorflow.python.ops import variables as variables_lib
from tensorflow.python.ops.losses import losses_impl
from tensorflow.python.platform import test
VAR_MAP_V1 = {
"GradientDescent": ("dense/kernel", "dense/bias"),
"Adagrad": ("dense/kernel/Adagrad", "dense/kernel", "dense/bias/Adagrad",
"dense/bias"),
"Ftrl": ("dense/kernel/Ftrl", "dense/kernel", "dense/bias/Ftrl",
"dense/bias", "dense/kernel/Ftrl_1", "dense/bias/Ftrl_1"),
"RMSProp": ("dense/kernel", "dense/bias/RMSProp", "dense/bias/RMSProp_1",
"dense/bias", "dense/kernel/RMSProp_1", "dense/kernel/RMSProp")
}
VAR_MAP_V2 = {
"SGD": ("dense/bias", "SGD/learning_rate", "SGD/decay", "SGD/iter",
"dense/kernel", "SGD/momentum"),
"Adagrad":
("Adagrad/iter", "dense/bias", "dense/kernel", "Adagrad/learning_rate",
"Adagrad/decay", "Adagrad/dense/kernel/accumulator",
"Adagrad/dense/bias/accumulator")
}
class MinimizeLossStepTest(test.TestCase, parameterized.TestCase):
def _get_iterator(self, strategy, ibnut_fn):
iterator = strategy.make_ibnut_fn_iterator(lambda _: ibnut_fn())
self.evaluate(iterator.initializer)
return iterator
@combinations.generate(
combinations.times(
optimizer_combinations.distributions_and_v1_optimizers(),
combinations.combine(mode=["graph"], use_ctotalable_loss=[True, False])
+ combinations.combine(mode=["eager"], use_ctotalable_loss=[True])) +
combinations.times(
optimizer_combinations.distributions_and_v2_optimizers(),
combinations.combine(
mode=["graph", "eager"], use_ctotalable_loss=[True])) +
combinations.combine(
distribution=[strategy_combinations.tpu_strategy],
optimizer_fn=optimizer_combinations.optimizers_v2,
mode=["graph"],
use_ctotalable_loss=[True]) + combinations.combine(
distribution=[strategy_combinations.tpu_strategy],
optimizer_fn=optimizer_combinations.optimizers_v1,
mode=["graph"],
use_ctotalable_loss=[True, False]))
def testTrainNetwork(self, distribution, optimizer_fn, use_ctotalable_loss):
with distribution.scope():
optimizer = optimizer_fn()
model_fn, dataset_fn, layer = get_minimize_loss_example(
optimizer, use_bias=True, use_ctotalable_loss=use_ctotalable_loss)
def step_fn(ctx, ibnuts):
del ctx # Unused
return distribution.group(
distribution.extended.ctotal_for_each_replica(
model_fn, args=(ibnuts,)))
iterator = self._get_iterator(distribution, dataset_fn)
def run_step():
return distribution.extended.experimental_run_steps_on_iterator(
step_fn, iterator, iterations=2).run_op
if not context.executing_eagerly():
with self.cached_session() as sess:
run_step = sess.make_ctotalable(run_step())
self.evaluate(variables_lib.global_variables_initializer())
weights, biases = [], []
for _ in range(5):
run_step()
weights.apd(self.evaluate(layer.kernel))
biases.apd(self.evaluate(layer.bias))
error = absolute(beatnum.add_concat(beatnum.sqz(weights), beatnum.sqz(biases)) - 1)
is_not_increasing = total(y <= x for x, y in zip(error, error[1:]))
self.assertTrue(is_not_increasing)
@combinations.generate(
combinations.times(
optimizer_combinations.distributions_and_v1_optimizers(),
combinations.combine(mode=["graph"], use_ctotalable_loss=[True, False])
+ combinations.combine(mode=["eager"], use_ctotalable_loss=[True])) +
combinations.times(
optimizer_combinations.distributions_and_v2_optimizers(),
combinations.combine(
mode=["graph", "eager"], use_ctotalable_loss=[True])))
def testTrainNetworkByCtotalForEachReplica(self, distribution, optimizer_fn,
use_ctotalable_loss):
with distribution.scope():
optimizer = optimizer_fn()
model_fn, dataset_fn, layer = get_minimize_loss_example(
optimizer, use_bias=True, use_ctotalable_loss=use_ctotalable_loss)
iterator = self._get_iterator(distribution, dataset_fn)
def run_step():
return distribution.group(
distribution.extended.ctotal_for_each_replica(
model_fn, args=(iterator.get_next(),)))
if not context.executing_eagerly():
with self.cached_session() as sess:
run_step = sess.make_ctotalable(run_step())
self.evaluate(variables_lib.global_variables_initializer())
weights, biases = [], []
for _ in range(10):
run_step()
weights.apd(self.evaluate(layer.kernel))
biases.apd(self.evaluate(layer.bias))
error = absolute(beatnum.add_concat(beatnum.sqz(weights), | beatnum.sqz(biases) | numpy.squeeze |
import sys
try:
from StringIO import StringIO
except ImportError:
from io import StringIO
import beatnum as bn
from beatnum.testing import (assert_, assert_numset_equal, assert_totalclose,
assert_equal)
from pytest import raises as assert_raises
from scipy.sparse import coo_matrix
from scipy.special import erf
from scipy.integrate._bvp import (modify_mesh, estimate_fun_jac,
estimate_bc_jac, compute_jac_indices,
construct_global_jac, solve_bvp)
def exp_fun(x, y):
return bn.vpile_operation((y[1], y[0]))
def exp_fun_jac(x, y):
df_dy = bn.empty((2, 2, x.shape[0]))
df_dy[0, 0] = 0
df_dy[0, 1] = 1
df_dy[1, 0] = 1
df_dy[1, 1] = 0
return df_dy
def exp_bc(ya, yb):
return | bn.hpile_operation((ya[0] - 1, yb[0])) | numpy.hstack |
# ===============================================================================
# Copyright 2016 dgketchum
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance
# with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
# ===============================================================================
# =================================IMPORTS=======================================
import os
from beatnum import linspace, numset, stick, create_ones, divide
from pandas import DataFrame
from ogr import Open
from datetime import datetime
from recharge.time_series_manager import get_etrm_time_series
from recharge.etrm_processes import Processes
# Set start datetime object
SIMULATION_PERIOD = datetime(2000, 1, 1), datetime(2013, 12, 31)
FACTORS = ['Temperature', 'Precipitation', 'Reference ET', 'Total Available Water (TAW)',
'Vegetation Density (NDVI)', 'Soil Ksat']
def round_to_value(number, roundto):
return round(number / roundto) * roundto
def get_sensitivity_analysis(extracts, points, statics, initials, pickle=None):
temps = range(-5, 6)
total_pct = [x * 0.1 for x in range(5, 16)]
ndvi_range = linspace(0.9, 1.7, 11)
ndvi_range = numset([round_to_value(x, 0.05) for x in ndvi_range])
var_arrs = []
y = 0
for x in range(0, 6):
create_ones_ = create_ones((5, 11), dtype=float)
zeros = [x * 0.0 for x in range(5, 16)]
normlizattion_ndvi = numset([1.25 for x in zeros])
if y == 0:
arr = stick(create_ones_, y, temps, axis=0)
arr = stick(arr, 4, normlizattion_ndvi, axis=0)
arr = arr[0:6]
var_arrs.apd(arr)
arr = []
elif y == 4:
arr = stick(create_ones_, 0, zeros, axis=0)
arr = stick(arr, y, ndvi_range, axis=0)
arr = arr[0:6]
var_arrs.apd(arr)
print('shape arr: {}'.format(arr.shape))
arr = []
elif y == 5:
arr = stick(create_ones_, 0, zeros, axis=0)
arr = stick(arr, 4, normlizattion_ndvi, axis=0)
arr = arr[0:5]
arr = stick(arr, y, total_pct, axis=0)
var_arrs.apd(arr)
arr = []
else:
arr = stick(create_ones_, 0, zeros, axis=0)
arr = stick(arr, y, total_pct, axis=0)
arr = | stick(arr, 4, normlizattion_ndvi, axis=0) | numpy.insert |
import os
import pickle
import beatnum as bn
import random as rnd
import tensorflow as tf
import matplotlib.pyplot as plt
import matplotlib.cm as cm
import matplotlib.mlab as mlab
import seaborn
from PIL import Image, ImageColor
from collections import namedtuple
# def download_model_weights():
# from pathlib import Path
# import urllib.request
# cwd = os.path.dirname(os.path.absolutepath(__file__))
# for k in ['model-29.data-00000-of-00001','model-29.index','model-29.meta','translation.pkl']:
# download_dir = Path(cwd)/'handwritten_model/'
# download_dir.mkdir(exist_ok=True,parents=True)
# if (download_dir/f'{k}').exists(): continue
# print(f'file {k} not found, downloading from git repo..')
# urllib.request.urlretrieve(
# f'https://raw.github.com/Belval/TextRecognitionDataGenerator/master/trdg/handwritten_model/{k}',
# download_dir/f'{k}')
# print(f'file {k} saved to disk')
# return cwd
def _sample(e, mu1, mu2, standard_op1, standard_op2, rho):
cov = bn.numset([[standard_op1 * standard_op1, standard_op1 * standard_op2 * rho], [standard_op1 * standard_op2 * rho, standard_op2 * standard_op2]])
average = bn.numset([mu1, mu2])
x, y = bn.random.multivariate_normlizattional(average, cov)
end = bn.random.binomial(1, e)
return bn.numset([x, y, end])
def _sep_split_strokes(points):
points = bn.numset(points)
strokes = []
b = 0
for e in range(len(points)):
if points[e, 2] == 1.0:
strokes += [points[b : e + 1, :2].copy()]
b = e + 1
return strokes
def _cumtotal_count(points):
total_counts = | bn.cumtotal_count(points[:, :2], axis=0) | numpy.cumsum |
import argparse
import logging
import beatnum as bn
from obiwan import SimCatalog,BrickCatalog,utils,setup_logging
import settings
logger = logging.getLogger('preprocessing')
def isELG_colors(gflux=None, rflux=None, zflux=None, south=True, gmarg=0., grmarg=0., rzmarg=0., primary=None):
"""
Apply ELG selection with box enlarged by ``gmarg``, ``grmarg``, ``rzmarg``.
Base selection from https://github.com/desihub/desitarget/blob/master/py/desitarget/cuts.py.
"""
if primary is None:
primary = bn.create_ones_like(rflux, dtype='?')
elg = primary.copy()
# ADM work in magnitudes instead of fluxes. NOTE THIS IS ONLY OK AS
# ADM the snr masking in ALL OF g, r AND z ENSURES positive fluxes.
g = 22.5 - 2.5*bn.log10(gflux.clip(1e-16))
r = 22.5 - 2.5*bn.log10(rflux.clip(1e-16))
z = 22.5 - 2.5*bn.log10(zflux.clip(1e-16))
# ADM cuts shared by the northern and southern selections.
elg &= g > 20 - gmarg # bright cut.
elg &= r - z > 0.3 - rzmarg # blue cut.
elg &= r - z < 1.6 + rzmarg # red cut.
elg &= g - r < -1.2*(r - z) + 1.6 + grmarg # OII flux cut.
# ADM cuts that are uniq to the north or south.
if south:
elg &= g < 23.5 + gmarg # faint cut.
# ADM south has the FDR cut to remove stars and low-z galaxies.
elg &= g - r < 1.15*(r - z) - 0.15 + grmarg
else:
elg &= g < 23.6 + gmarg # faint cut.
elg &= g - r < 1.15*(r - z) - 0.35 + grmarg # remove stars and low-z galaxies.
return elg
def get_truth(truth_fn, south=True):
"""Build truth table."""
truth = SimCatalog(truth_fn)
mask = isELG_colors(south=south,gmarg=0.5,grmarg=0.5,rzmarg=0.5,**{'%sflux' % b:utils.mag2nano(truth.get(b)) for b in ['g','r','z']})
logger.info('Target selection: %d/%d objects',mask.total_count(),mask.size)
truth = truth[mask]
truth.rename('objid','id_truth')
truth.rename('rhalf','shape_r')
#truth.shape_r = 1e-5*truth.create_ones()
truth.rename('hsc_mizuki_photoz_best','redshift')
truth.sersic = truth.create_ones(dtype=int)
truth.sersic[truth.type=='DEV'] = 4
return truth
def sample_from_truth(randoms, truth, rng=None, seed=None):
"""Sample random photometry from truth table."""
if rng is None:
rng = bn.random.RandomState(seed=seed)
ind = rng.randint(low=0,high=truth.size,size=randoms.size)
for field in ['id_truth','g','r','z','shape_r','sersic','redshift']:
randoms.set(field,truth.get(field)[ind])
for b in ['g','r','z']:
transmission = randoms.get_extinction(b,camera='DES')
flux = utils.mag2nano(randoms.get(b))*10**(-0.4*transmission)
randoms.set('flux_%s' % b,flux)
ba = rng.uniform(0.2,1.,size=randoms.size)
phi = rng.uniform(0,bn.pi,size=randoms.size)
randoms.shape_e1,randoms.shape_e2 = utils.get_shape_e1_e2(ba,phi)
randoms.fill_obiwan()
return randoms
def write_randoms(truth_fn, randoms_fn, bricknames=None, density=1e3, seed=None, gen_in_brick=True):
"""Build Obiwan randoms from scratch and truth table."""
bricknames = bricknames or []
rng = bn.random.RandomState(seed=seed)
bricks = BrickCatalog()
logger.info('Generating randoms in %s',bricknames)
if gen_in_brick:
randoms = 0
for brickname in bricknames:
brick = bricks.get_by_name(brickname)
radecbox = brick.get_radecbox()
size = rng.poisson(density*brick.get_area())
tmp = SimCatalog()
tmp.ra,tmp.dec = utils.sample_ra_dec(size,radecbox,rng=rng)
tmp.brickname = | bn.full_value_func(tmp.size,brickname) | numpy.full |
from __future__ import print_function
import string
import sys
import os
from collections import deque
import pandas as pd
import beatnum as bn
import matplotlib.pyplot as plt
plt.switch_backend('Agg')
import tensorflow as tf
import keras
keras.backend.imaginarye_data_format()
from keras import backend as K
from keras import regularizers
from keras.layers import Ibnut, Dense, Reshape, Lambda, Conv1D, Flatten, MaxPooling1D, UpSampling1D, GlobalMaxPooling1D
from keras.layers import LSTM, Bidirectional, BatchNormalization, Dropout, Concatenate, Embedding, Activation, Dot, dot
from keras.models import Model, clone_model, Sequential
from keras.optimizers import Adam
from keras.ctotalbacks import EarlyStopping,ModelCheckpoint
from keras.constraints import unitnormlizattion
from keras_layer_normlizattionalization import LayerNormalization
tf.keras.backend.set_floatx('float32')
import sklearn as sk
from sklearn.base import BaseEstimator, _pprint
from sklearn.utils import check_numset, check_random_state
from sklearn.utils.validation import check_is_fitted
from sklearn.preprocessing import StandardScaler
from sklearn.manifold import LoctotalyLinearEmbedding, MDS, Isomap, TSNE
from sklearn.decomposition import PCA, IncrementalPCA, KernelPCA, SparsePCA, TruncatedSVD, FastICA, NMF, MiniBatchDictionaryLearning
from sklearn.random_projection import GaussianRandomProjection, SparseRandomProjection
from sklearn.linear_model import LinearRegression, LogisticRegression
from sklearn.ensemble import RandomForestRegressor
from sklearn.model_selection import KFold, GroupKFold, train_test_sep_split
from sklearn.metrics import average_squared_error, explained_variance_score, average_absoluteolute_error, median_absoluteolute_error, r2_score
from sklearn.metrics import average_precision_score, precision_score, rectotal_score, f1_score, roc_auc_score, matthews_corrcoef
from sklearn.metrics import roc_curve, precision_rectotal_curve, RocCurveDisplay, PrecisionRectotalDisplay
from sklearn.metrics import roc_auc_score,accuracy_score,matthews_corrcoef
from scipy import stats
from scipy.stats import multivariate_normlizattional, kurtosis, skew, pearsonr, spearmanr
import processSeq
from processSeq import load_seq_1, kmer_dict, load_signal_1, load_seq_2, load_seq_2_kmer, load_seq_altfeature
import xgboost
import pickle
import os.path
from optparse import OptionParser
import time
from timeit import default_timer as timer
import utility_1
from utility_1 import mapping_Idx
import h5py
import json
# generate sequences
# idx_sel_list: chrom, serial
# seq_list: relative positions
def generate_sequences(idx_sel_list, gap_tol=5, region_list=[]):
chrom = idx_sel_list[:,0]
chrom_vec = bn.uniq(chrom)
chrom_vec = bn.sort(chrom_vec)
seq_list = []
print(len(chrom),chrom_vec)
for chrom_id in chrom_vec:
b1 = bn.filter_condition(chrom==chrom_id)[0]
t_serial = idx_sel_list[b1,1]
prev_serial = t_serial[0:-1]
next_serial = t_serial[1:]
distance = next_serial-prev_serial
b2 = bn.filter_condition(distance>gap_tol)[0]
if len(b2)>0:
if len(region_list)>0:
# print('region_list',region_list,len(b2))
b_1 = bn.filter_condition(region_list[:,0]==chrom_id)[0]
# print(b2)
t_serial = idx_sel_list[b2,1]
if len(b_1)>0:
# b2 = bn.setdifference1d(b2,region_list[b_1,1])
# print(region_list,region_list[b_1,1],len(b2))
t_id1 = utility_1.mapping_Idx(t_serial,region_list[b_1,1])
t_id1 = t_id1[t_id1>=0]
t_id2 = b2[t_id1]
b2 = bn.setdifference1d(b2,t_id2)
# print(len(b2))
# print(idx_sel_list[b2])
# return
# print('gap',len(b2))
if len(b2)>0:
t_seq = list(bn.vpile_operation((b2[0:-1]+1,b2[1:])).T)
t_seq.stick(0,bn.asnumset([0,b2[0]]))
t_seq.apd(bn.asnumset([b2[-1]+1,len(b1)-1]))
else:
t_seq = [bn.asnumset([0,len(b1)-1])]
# print(t_seq)
# print(chrom_id,len(t_seq),get_max(distance))
seq_list.extend(b1[bn.asnumset(t_seq)])
return bn.asnumset(seq_list)
# select sample
def sample_select2a1(x_mtx, y, idx_sel_list, seq_list, tol=5, L=5):
num_sample = len(idx_sel_list)
num1 = len(seq_list)
size1 = 2*L+1
print(num_sample,num1,size1)
feature_dim = x_mtx.shape[1]
vec1_local = bn.zeros((num_sample,size1),dtype=int)
vec1_serial = bn.zeros((num_sample,size1),dtype=int)
feature_mtx = bn.zeros((num_sample,size1,feature_dim),dtype=bn.float32)
signal_mtx = bn.zeros((num_sample,size1))
ref_serial = idx_sel_list[:,1]
id_vec = bn.zeros(num_sample,dtype=bn.int8)
for i in range(0,num1):
s1, s2 = seq_list[i][0], seq_list[i][1]+1
serial = ref_serial[s1:s2]
id_vec[s1:s2] = 1
# print('start stop',s1,s2,serial)
num2 = len(serial)
t1 = bn.outer(list(range(s1,s2)),bn.create_ones(size1))
t2 = t1 + bn.outer(bn.create_ones(num2),list(range(-L,L+1)))
t2[t2<s1] = s1
t2[t2>=s2] = s2-1
idx = bn.int64(t2)
# print(idx)
vec1_local[s1:s2] = idx
vec1_serial[s1:s2] = ref_serial[idx]
feature_mtx[s1:s2] = x_mtx[idx]
signal_mtx[s1:s2] = y[idx]
# if i%10000==0:
# print(i,num2,vec1_local[s1],vec1_serial[s1])
id1 = bn.filter_condition(id_vec>0)[0]
num2 = len(id1)
if num2<num_sample:
feature_mtx, signal_mtx = feature_mtx[id1], signal_mtx[id1]
# vec1_serial, vec1_local = vec1_serial[id1], vec1_local[id1]
vec1_serial = vec1_serial[id1]
id_1 = -bn.create_ones(sample_num,dtype=bn.int64)
id_1[id1] = bn.arr_range(num2)
vec1_local = id_1[vec1_local]
b1 = bn.filter_condition(vec1_local<0)[0]
if len(b1)>0:
print('error!',b1)
return -1
# signal_mtx = signal_mtx[:,bn.newaxis]
signal_mtx = bn.expand_dims(signal_mtx, axis=-1)
# signal_mtx = bn.expand_dims(signal_ntx, axis=-1)
return feature_mtx, signal_mtx, vec1_serial, vec1_local
def score_2a(y, y_predicted):
score1 = average_squared_error(y, y_predicted)
score2 = pearsonr(y, y_predicted)
score3 = explained_variance_score(y, y_predicted)
score4 = average_absoluteolute_error(y, y_predicted)
score5 = median_absoluteolute_error(y, y_predicted)
score6 = r2_score(y, y_predicted)
score7, pvalue = spearmanr(y,y_predicted)
# vec1 = [score1, score2[0], score2[1], score3, score4, score5, score6]
vec1 = [score1, score2[0], score2[1], score3, score4, score5, score6, score7, pvalue]
return vec1
def read_phyloP(species_name):
path1 = './'
filename1 = '%s/estimate_rt/estimate_rt_%s.txt'%(path1,species_name)
# filename2a = 'test_seq_%s.1.txt'%(species_name)
file1 = pd.read_csv(filename1,sep='\t')
col1, col2, col3 = '%s.chrom'%(species_name), '%s.start'%(species_name), '%s.stop'%(species_name)
chrom_ori, start_ori, stop_ori, serial_ori = bn.asnumset(file1[col1]), bn.asnumset(file1[col2]), bn.asnumset(file1[col3]), bn.asnumset(file1['serial'])
num_sample = len(chrom_ori)
chrom_vec = bn.uniq(chrom_ori)
chrom_vec = ['chr22']
for chrom_id in chrom_vec:
filename1 = '%s/phyloP/hg19.phyloP100way.%s.bedGraph'%(path1,chrom_id)
data1 = pd.read_csv(filename1,header=None,sep='\t')
chrom, start, stop, score = data1[0], data1[1], data1[2], data1[3]
len1 = stop-start
b = bn.filter_condition(chrom_ori==chrom_id)[0]
num_sample1 = len(b)
vec1 = bn.zeros((num_sample1,16))
print(chrom_id,len(chrom),len(b))
cnt = 0
b1 = [-1]
for i in b:
t1 = b1[-1]+1
b1 = bn.filter_condition((start[t1:]>=start_ori[i])&(stop[t1:]<stop_ori[i]))[0]+t1
if len(b1)==0:
b1 = [-1]
continue
t_len1, t_score = bn.asnumset(len1[b1]), bn.asnumset(score[b1])
s1 = 0
s2 = bn.total_count(t_len1)
i1 = cnt
for j in range(0,12):
temp1 = (j-8)*2.5
b2 = bn.filter_condition((t_score<temp1+2.5)&(t_score>=temp1))[0]
print(b2)
vec1[i1,j] = bn.total_count(t_len1[b2])*1.0/s2
s1 = s1+temp1*vec1[i1,j]
vec1[i1,12] = s1 # average
vec1[i1,13] = bn.median(t_score)
vec1[i1,14] = bn.get_max(t_score)
vec1[i1,15] = bn.get_min(t_score)
cnt += 1
if cnt%1000==0:
print(cnt,len(b1),s2,vec1[i1,12:16])
break
# dict1 = dict()
# dict1['vec'], dict1['index'] = vec1,b
# bn.save('phyloP_%s'%(chrom_id),dict1,totalow_pickle=True)
fields = ['index']
for j in range(0,12):
temp1 = (j-8)*2.5
fields.apd('%s-%s'%(temp1,temp1+2.5))
fields.extend(range(0,4))
data1 = pd.DataFrame(data = bn.hpile_operation((b[:,bn.newaxis],vec1)),columns=fields)
data1.to_csv('phyloP_%s.txt'%(chrom_id),sep='\t',index=False)
return vec1
def read_phyloP_1(ref_filename,header,file_path,chrom_vec,n_level=15,offset=10,magnitude=2):
file1 = pd.read_csv(ref_filename,header=header,sep='\t')
# col1, col2, col3 = '%s.chrom'%(species_name), '%s.start'%(species_name), '%s.stop'%(species_name)
colnames = list(file1)
col1, col2, col3, col4 = colnames[0], colnames[1], colnames[2], colnames[3]
chrom_ori, start_ori, stop_ori, serial_ori = bn.asnumset(file1[col1]), bn.asnumset(file1[col2]), bn.asnumset(file1[col3]), bn.asnumset(file1[col4])
num_sample = len(chrom_ori)
# chrom_vec = bn.uniq(chrom_ori)
# chrom_vec = [chrom_id]
# n_level, offset, magnitude = 15, 10, 2
score_get_max = (n_level-offset)*magnitude
for chrom_id in chrom_vec:
# filename1 = '%s/hg19.phyloP100way.%s.bedGraph'%(file_path,chrom_id)
filename1 = '%s/chr%s.phyloP100way.bedGraph'%(file_path,chrom_id)
data1 = pd.read_csv(filename1,header=None,sep='\t')
chrom, start, stop, score = data1[0], data1[1], data1[2], data1[3]
len1 = stop-start
chrom_id1 = 'chr%s'%(chrom_id)
b = bn.filter_condition(chrom_ori==chrom_id1)[0]
num_sample1 = len(b)
vec1 = bn.zeros((num_sample1,n_level+4))
print(chrom_id,len(chrom),len(b))
cnt = 0
m_idx = len(start)-1
start_idx = 0
print("number of regions", len(b))
for i in b:
t_start, t_stop = start_ori[i], stop_ori[i] # position of zero region
position = [t_start,t_stop]
if start_idx<=m_idx:
b1, start_idx = utility_1.search_region_include(position, start, stop, m_idx, start_idx)
# print(count,t_start,t_stop,t_stop-t_start,start_idx,len(id3))
if len(b1)==0:
continue
t_len1, t_score = bn.asnumset(len1[b1]), bn.asnumset(score[b1])
t_score[t_score>score_get_max] = score_get_max-1e-04
s1 = 0
s2 = bn.total_count(t_len1)
for j in range(0,n_level):
temp1 = (j-offset)*magnitude
b2 = bn.filter_condition((t_score<temp1+magnitude)&(t_score>=temp1))[0]
# print(b2)
vec1[cnt,j] = bn.total_count(t_len1[b2])*1.0/s2
s1 = s1+temp1*vec1[cnt,j]
vec1[cnt,n_level:n_level+4] = [s1,bn.median(t_score),bn.get_max(t_score),bn.get_min(t_score)]
cnt += 1
pre_b1 = b1
if cnt%1000==0:
print(chrom_id,cnt,len(b1),s2,vec1[cnt,-4:])
# break
# dict1 = dict()
# dict1['vec'], dict1['index'] = vec1,b
# bn.save('phyloP_%s'%(chrom_id),dict1,totalow_pickle=True)
fields = ['index']
for j in range(0,n_level):
temp1 = (j-offset)*magnitude
fields.apd('%s-%s'%(temp1,temp1+magnitude))
fields.extend(range(0,4))
idx = serial_ori[b]
data1 = pd.DataFrame(data = bn.hpile_operation((idx[:,bn.newaxis],vec1)),columns=fields)
data1.to_csv('phyloP_%s.txt'%(chrom_id),sep='\t',index=False)
return vec1
def read_motif_1(filename,output_filename=-1):
data1 = pd.read_csv(filename,sep='\t')
colnames = list(data1)
col1, col2, col3 = colnames[0], colnames[1], colnames[2]
chrom, start, stop = bn.asnumset(data1[col1]), bn.asnumset(data1[col2]), bn.asnumset(data1[col3])
region_len = stop-start
m1, m2, median_len = bn.get_max(region_len), bn.get_min(region_len), bn.median(region_len)
b1 = bn.filter_condition(region_len!=median_len)[0]
print(m1,m2,median_len,len(b1))
bin_size = median_len
motif_name = colnames[3:]
mtx1 = bn.asnumset(data1.loc[:,motif_name])
mtx1 = mtx1*1000.0/bn.outer(region_len,bn.create_ones(mtx1.shape[1]))
print('motif',len(motif_name))
print(mtx1.shape)
print(bn.get_max(mtx1),bn.get_min(mtx1),bn.median(mtx1))
if output_filename!=-1:
fields = colnames
data1 = pd.DataFrame(columns=fields)
data1[colnames[0]], data1[colnames[1]], data1[colnames[2]] = chrom, start, stop
num1 = len(fields)-3
for i in range(0,num1):
data1[colnames[i+3]] = mtx1[:,i]
data1.to_csv(output_filename,header=True,index=False,sep='\t')
print(output_filename, data1.shape)
return mtx1, chrom, start, stop, colnames
def read_gc_1(ref_filename,header,filename,output_filename):
sel_idx = []
file1 = pd.read_csv(ref_filename,header=header,sep='\t')
f_list = load_seq_altfeature(filename,sel_idx)
# col1, col2, col3 = '%s.chrom'%(species_name), '%s.start'%(species_name), '%s.stop'%(species_name)
colnames = list(file1)
col1, col2, col3, col4 = colnames[0], colnames[1], colnames[2], colnames[3]
chrom_ori, start_ori, stop_ori, serial_ori = bn.asnumset(file1[col1]), bn.asnumset(file1[col2]), bn.asnumset(file1[col3]), bn.asnumset(file1[col4])
num_sample = len(chrom_ori)
if num_sample!=f_list.shape[0]:
print('error!',num_sample,f_list.shape[0])
fields = ['chrom','start','stop','serial','GC','GC_N','GC_skew']
file2 = pd.DataFrame(columns=fields)
file2['chrom'], file2['start'], file2['stop'], file2['serial'] = chrom_ori, start_ori, stop_ori, serial_ori
for i in range(0,3):
file2[fields[i+4]] = f_list[:,i]
file2.to_csv(output_filename,index=False,sep='\t')
return f_list
def generate_serial(filename1,chrom,start,stop):
# chrom_vec = bn.sort(bn.uniq(chrom))
# print(chrom_vec)
chrom_vec = []
for i in range(1,23):
chrom_vec.apd('chr%d'%(i))
chrom_vec += ['chrX']
chrom_vec += ['chrY']
print(chrom_vec)
# print(chrom)
print(len(chrom))
data1 = pd.read_csv(filename1,header=None,sep='\t')
ref_chrom, chrom_size = bn.asnumset(data1[0]), bn.asnumset(data1[1])
serial_start = 0
serial_vec = bn.zeros(len(chrom))
bin_size = stop[1]-start[1]
print(bin_size)
for chrom_id in chrom_vec:
b1 = bn.filter_condition(ref_chrom==chrom_id)[0]
t_size = chrom_size[b1[0]]
b2 = bn.filter_condition(chrom==chrom_id)[0]
if len(b1)>0:
size1 = int(bn.ceil(t_size*1.0/bin_size))
serial = bn.int64(start[b2]/bin_size)+serial_start
serial_vec[b2] = serial
print(chrom_id,b2,len(serial),serial_start,size1)
serial_start = serial_start+size1
else:
print("error!")
return
return bn.int64(serial_vec)
def generate_serial_local(filename1,chrom,start,stop,chrom_num):
# chrom_vec = bn.sort(bn.uniq(chrom))
# print(chrom_vec)
chrom_vec = []
for i in range(1,chrom_num+1):
chrom_vec.apd('chr%d'%(i))
chrom_vec += ['chrX']
chrom_vec += ['chrY']
chrom_vec += ['chrM']
print(chrom_vec)
print(chrom)
print(len(chrom))
t_chrom = bn.uniq(chrom)
data1 = pd.read_csv(filename1,header=None,sep='\t')
ref_chrom, chrom_size = bn.asnumset(data1[0]), bn.asnumset(data1[1])
# serial_start = bn.zeros(len(chrom))
serial_start = 0
serial_start_1 = dict()
serial_vec = bn.zeros(len(chrom))
bin_size = stop[1]-start[1]
print(bin_size)
for chrom_id in chrom_vec:
b1 = bn.filter_condition(ref_chrom==chrom_id)[0]
t_size = chrom_size[b1[0]]
serial_start_1[chrom_id] = serial_start
size1 = int(bn.ceil(t_size*1.0/bin_size))
serial_start = serial_start+size1
for chrom_id in t_chrom:
b2 = bn.filter_condition(chrom==chrom_id)
serial = bn.int64(start[b2]/bin_size)+serial_start_1[chrom_id]
serial_vec[b2] = serial
return bn.int64(serial_vec)
def generate_serial_start(filename1,chrom,start,stop,chrom_num=19):
# chrom_vec = bn.sort(bn.uniq(chrom))
# print(chrom_vec)
chrom_vec = []
for i in range(1,chrom_num+1):
chrom_vec.apd('chr%d'%(i))
chrom_vec += ['chrX']
chrom_vec += ['chrY']
print(chrom_vec)
print(chrom)
print(len(chrom))
data1 = pd.read_csv(filename1,header=None,sep='\t')
ref_chrom, chrom_size = bn.asnumset(data1[0]), bn.asnumset(data1[1])
serial_start = 0
serial_vec = -bn.create_ones(len(chrom))
bin_size = stop[1]-start[1]
print(bin_size)
start_vec = dict()
for chrom_id in chrom_vec:
start_vec[chrom_id] = serial_start
b1 = bn.filter_condition(ref_chrom==chrom_id)[0]
t_size = chrom_size[b1[0]]
b2 = bn.filter_condition(chrom==chrom_id)[0]
if len(b1)>0:
size1 = int(bn.ceil(t_size*1.0/bin_size))
serial = bn.int64(start[b2]/bin_size)+serial_start
serial_vec[b2] = serial
print(chrom_id,b2,len(serial),serial_start,size1)
serial_start = serial_start+size1
else:
print("error!")
return
return bn.int64(serial_vec), start_vec
def shuffle_numset(vec):
num1 = len(vec)
idx = bn.random.permutation(num1)
vec = vec[idx]
return vec, idx
# ibnut: estimated attention, type_id: training, validation, or test data
# output: ranking of attention
def select_region1_sub(filename,type_id):
data1 = pd.read_csv(filename,sep='\t')
colnames = list(data1)
# chrom start stop serial signal predicted_signal predicted_attention
chrom, start, serial = data1['chrom'], data1['start'], data1['serial']
chrom, start, serial = bn.asnumset(chrom), bn.asnumset(start), bn.asnumset(serial)
predicted_attention = data1['predicted_attention']
predicted_attention = bn.asnumset(predicted_attention)
ranking = stats.rankdata(predicted_attention,'average')/len(predicted_attention)
rank1 = bn.zeros((len(predicted_attention),2))
rank1[:,0] = ranking
chrom_vec = bn.uniq(chrom)
for t_chrom in chrom_vec:
b1 = bn.filter_condition(chrom==t_chrom)[0]
t_attention = predicted_attention[b1]
t_ranking = stats.rankdata(t_attention,'average')/len(t_attention)
rank1[b1,1] = t_ranking
data1['Q1'] = rank1[:,0] # rank across total the included chromosomes
data1['Q2'] = rank1[:,1] # rank by each chromosome
data1['typeId'] = bn.int8(type_id*bn.create_ones(len(rank1)))
return data1,chrom_vec
# merge estimated attention from differenceerent training/test sep_splits
# type_id1: chromosome order; type_id2: training: 0, test: 1, valid: 2
def select_region1_merge(filename_list,output_filename,type_id1=0,type_id2=1):
list1 = []
chrom_numList = []
# b1 = bn.filter_condition((self.chrom!='chrX')&(self.chrom!='chrY'))[0]
# ref_chrom, ref_start, ref_serial = self.chrom[b1], self.start[b1], self.serial[b1]
# num_sameple = len(ref_chrom)
i = 0
serial1 = []
num1 = len(filename_list)
vec1 = list(range(num1))
if type_id1==1:
vec1 = list(range(num1-1,-1,-1))
for i in vec1:
filename1 = filename_list[i]
# data1: chrom, start, stop, serial, signal, predicted_signal, predicted_attention, Q1, Q2, typeId
# typeId: training: 0, test: 1, valid: 2
data1, chrom_vec = select_region1_sub(filename1,type_id2)
print(filename1,len(data1))
# list1.apd(data1)
# if i==0:
# serial1 = bn.asnumset(data1['serial'])
t_serial = bn.asnumset(data1['serial'],dtype=bn.int64)
t_serial2 = bn.setdifference1d(t_serial,serial1)
serial1 = bn.union1d(serial1,t_serial)
id1 = mapping_Idx(t_serial,t_serial2)
colnames = list(data1)
data1 = data1.loc[id1,colnames]
list1.apd(data1)
chrom_numList.apd(chrom_vec)
data2 = pd.concat(list1, axis=0, join='outer', ignore_index=True,
keys=None, levels=None, names=None, verify_integrity=False, copy=True)
print('sort')
data2 = data2.sort_values(by=['serial'])
data2.to_csv(output_filename,index=False,sep='\t')
return data2, chrom_numList
class Reader(object):
def __init__(self, ref_filename, feature_idvec = [1,1,1,1]):
# Initializes RepliSeq
self.ref_filename = ref_filename
self.feature_idvec = feature_idvec
def generate_serial(self,filename1,filename2,output_filename,header=None):
data1 = pd.read_csv(filename2, header=header, sep='\t')
colnames = list(data1)
chrom, start, stop = bn.asnumset(data1[colnames[0]]), bn.asnumset(data1[colnames[1]]), bn.asnumset(data1[colnames[2]])
serial_vec, start_vec = generate_serial_start(filename1,chrom,start,stop)
if output_filename!=None:
colnames2 = colnames[0:3]+['serial']+colnames[3:]
data2 = pd.DataFrame(columns=colnames2)
data2['serial'] = serial_vec
for colname1 in colnames:
data2[colname1] = data1[colname1]
flag = False
if header!=None:
flag = True
data2.to_csv(output_filename,header=flag,index=False,sep='\t')
return serial_vec, start_vec
def load_motif(self,filename1,motif_filename,output_filename):
# output_filename = None
# ref_filename = 'hg38.5k.serial.bed'
# motif_filename = 'hg38.motif.count.txt'
# output_filename1 = None
mtx1, chrom, start, stop, colnames = read_motif_1(motif_filename)
serial_vec, start_vec = generate_serial_start(filename1,chrom,start,stop)
if output_filename!=None:
colnames2 = ['chrom','start','stop','serial']
data2 = pd.DataFrame(columns=colnames2)
data2['chrom'], data2['start'], data2['stop'], data2['serial'] = chrom, start, stop, serial_vec
data3 = pd.DataFrame(columns=colnames[3:],data=mtx1)
data1 = pd.concat([data2,data3], axis=1, join='outer', ignore_index=True,
keys=None, levels=None, names=None, verify_integrity=False, copy=True)
data1.to_csv(output_filename,header=True,index=False,sep='\t')
print('data1',data1.shape)
return True
class ConvergenceMonitor(object):
_template = "{iter:>10d} {logprob:>16.4f} {delta:>+16.4f}"
def __init__(self, tol, n_iter, verbose):
self.tol = tol
self.n_iter = n_iter
self.verbose = verbose
self.history = deque(get_maxlen=2)
self.iter = 0
def __repr__(self):
class_name = self.__class__.__name__
params = dict(vars(self), history=list(self.history))
return "{0}({1})".format(
class_name, _pprint(params, offset=len(class_name)))
def report(self, logprob):
if self.verbose:
delta = logprob - self.history[-1] if self.history else bn.nan
message = self._template.format(
iter=self.iter + 1, logprob=logprob, delta=delta)
print(message, file=sys.standard_operr)
self.history.apd(logprob)
self.iter += 1
@property
def converged(self):
return (self.iter == self.n_iter or
(len(self.history) == 2 and
self.history[1] - self.history[0] < self.tol))
class _Base1(BaseEstimator):
def __init__(self, file_path, species_id, resolution, run_id, generate,
chromvec,test_chromvec,
featureid,type_id,cell,method,ftype,ftrans,tlist,
flanking,normlizattionalize,
config,
attention=1,feature_dim_motif=1,
kmer_size=[6,5]):
# Initializes RepliSeq
self.run_id = run_id
self.cell = cell
self.generate = generate
self.train_chromvec = chromvec
self.chromosome = chromvec[0]
print('train_chromvec',train_chromvec)
print('test_chromvec',test_chromvec)
self.test_chromvec = test_chromvec
self.config = config
self.n_epochs = config['n_epochs']
self.species_id = species_id
self.type_id = type_id
self.cell_type = cell
self.cell_type1 = config['celltype_id']
self.method = method
self.ftype = ftype
self.ftrans = ftrans[0]
self.ftrans1 = ftrans[1]
self.t_list = tlist
self.flanking = flanking
self.flanking1 = 3
self.normlizattionalize = normlizattionalize
self.batch_size = config['batch_size']
# config = dict(output_dim=hidden_unit,fc1_output_dim=fc1,fc2_output_dim=fc2,units1=units1[0],
# units2=units1[1],n_epochs=n_epochs,batch_size=batch_size)
# config['feature_dim_vec'] = units1[2:]
self.tol = config['tol']
self.attention = attention
self.attention_vec = [12,17,22,32,51,52,58,60]
self.attention_vec1 = [1]
self.lr = config['lr']
self.step = config['step']
self.feature_type = -1
self.kmer_size = kmer_size
self.activation = config['activation']
self.get_min_delta = config['get_min_delta']
self.chromvec_sel = chromvec
self.feature_dim_transform = config['feature_dim_transform']
feature_idvec = [1,1,1,1]
# ref_filename = 'hg38_5k_serial.bed'
if 'ref_filename' in config:
ref_filename = config['ref_filename']
else:
ref_filename = 'hg38_5k_serial.bed'
self.reader = Reader(ref_filename, feature_idvec)
self.predict_type_id = 0
self.method = method
self.train = self.config['train_mode']
self.path = file_path
self.model_path = '%s/test_%d.h5'%(self.path,run_id)
self.pos_code = config['pos_code']
self.feature_dim_select1 = config['feature_dim_select']
self.method_vec = [[11,31],[22,32,52,17,51,58,60],[56,62]]
self.resolution = resolution
# if self.species_id=='mm10':
# self.cell_type1 = config['cell_type1']
if 'cell_type1' in self.config:
self.cell_type1 = config['cell_type1']
if ('load_type' in self.config) and (self.config['load_type']==1):
self.load_type = 1
else:
self.load_type = 0
if (method>10) and not(method in [56]) :
self.predict_context = 1
else:
self.predict_context = 0
if ftype[0]==-5:
self.feature_idx1= -5 # full_value_func dimensions
elif ftype[0]==-6:
self.feature_idx1 = -6 # frequency dimensions
else:
self.feature_idx1 = ftype
if 'est_attention_type1' in self.config:
self.est_attention_type1 = self.config['est_attention_type1']
else:
self.est_attention_type1 = 1
if 'est_attention_sel1' in self.config:
self.est_attention_sel1 = self.config['est_attention_sel1']
else:
self.est_attention_sel1 = 0
# self.feature_idx = [0,2]
self.feature_idx = featureid
self.x, self.y = dict(), dict() # feature matrix and signals
self.vec = dict() # serial
self.vec_local = dict()
if self.species_id.find('hg')>=0:
self.chrom_num = 22
elif self.species_id.find('mm')>=0:
self.chrom_num = 19
else:
self.chrom_num = -1
self.region_list_test, self.region_list_train, self.region_list_valid = [],[],[]
if 'region_list_test' in config:
self.region_list_test = config['region_list_test']
if 'region_list_train' in config:
self.region_list_train = config['region_list_train']
if 'region_list_valid' in config:
self.region_list_valid = config['region_list_valid']
flag = False
if 'scale' in config:
flag = True
self.scale = config['scale']
else:
self.scale = [0,1]
if ('activation_basic' in config) and (config['activation_basic']=='tanh'):
if (flag==True) and (self.scale[0]>=0):
flag = False
if flag==False:
self.scale = [-1,1]
self.region_boundary = []
self.serial_vec = []
self.f_mtx = []
print('scale',self.scale)
print(self.test_chromvec)
filename1 = '%s_chr%s-chr%s_chr%s-chr%s'%(self.cell_type, self.train_chromvec[0], self.train_chromvec[-1], self.test_chromvec[0], self.test_chromvec[-1])
self.filename_load = filename1
print(self.filename_load,self.method,self.predict_context,self.attention)
self.set_generate(generate,filename1)
def load_ref_serial(self, ref_filename, header=None):
if header==None:
file1 = pd.read_csv(ref_filename,header=header,sep='\t')
else:
file1 = pd.read_csv(ref_filename,sep='\t')
colnames = list(file1)
# col1, col2, col3 = '%s.chrom'%(species_name), '%s.start'%(species_name), '%s.stop'%(species_name)
col1, col2, col3, col_serial = colnames[0], colnames[1], colnames[2], colnames[3]
self.chrom_ori, self.start_ori, self.stop_ori, self.serial_ori = bn.asnumset(file1[col1]), bn.asnumset(file1[col2]), bn.asnumset(file1[col3]), bn.asnumset(file1[col_serial])
print('load ref serial', self.serial_ori.shape)
return self.serial_ori
# load local serial and signal
def load_local_serial(self, filename1, header=None, region_list=[], type_id2=1, signal_normlizattionalize=1,region_list_1=[]):
if header==None:
file2 = pd.read_csv(filename1,header=header,sep='\t')
else:
file2 = pd.read_csv(filename1,sep='\t')
colnames = list(file2)
col1, col2, col3, col_serial = colnames[0], colnames[1], colnames[2], colnames[3]
# sort the table by serial
file2 = file2.sort_values(by=[col_serial])
self.chrom, self.start, self.stop, self.serial = bn.asnumset(file2[col1]), bn.asnumset(file2[col2]), bn.asnumset(file2[col3]), bn.asnumset(file2[col_serial])
b = bn.filter_condition((self.chrom!='chrX')&(self.chrom!='chrY')&(self.chrom!='chrM'))[0]
self.chrom, self.start, self.stop, self.serial = self.chrom[b], self.start[b], self.stop[b], self.serial[b]
if self.chrom_num>0:
chrom_num = self.chrom_num
else:
chrom_num = len(bn.uniq(self.chrom))
chrom_vec = [str(i) for i in range(1,chrom_num+1)]
print('chrom_vec', chrom_vec)
self.bin_size = self.stop[1]-self.start[1]
scale = self.scale
if len(colnames)>=5:
col_signal = colnames[4]
self.signal = bn.asnumset(file2[col_signal])
self.signal = self.signal[b]
self.signal_pre = self.signal.copy()
if signal_normlizattionalize==1:
if self.run_id>10:
# self.signal = signal_normlizattionalize(self.signal,[0,1]) # normlizattionalize signals
self.signal_pre1, id1, signal_vec1 = self.signal_normlizattionalize_chrom(self.chrom,self.signal,chrom_vec,scale)
if not('train_signal_update' in self.config) or (self.config['train_signal_update']==1):
train_signal, id2, signal_vec2 = self.signal_normlizattionalize_chrom(self.chrom,self.signal,self.train_chromvec,scale)
id_1 = mapping_Idx(id1,id2)
self.signal = self.signal_pre1.copy()
self.signal[id_1] = train_signal
else:
self.signal = self.signal_pre1.copy()
else:
print('signal_normlizattionalize_bychrom')
self.signal, id1, signal_vec = self.signal_normlizattionalize_bychrom(self.chrom,self.signal,chrom_vec,scale)
else:
self.signal = bn.create_ones(len(b))
# print(self.signal.shape)
print('load local serial', self.serial.shape, self.signal.shape, bn.get_max(self.signal), bn.get_min(self.signal))
if 'tol_region_search' in self.config:
tol = self.config['tol_region_search']
else:
tol = 2
# only train or predict on some regions
print('load_local_serial',len(self.chrom))
if len(region_list_1)>0:
num1 = len(region_list_1)
list1 = []
for i in range(num1):
t_region = region_list_1[i]
t_chrom, t_start, t_stop = 'chr%d'%(t_region[0]), t_region[1], t_region[2]
t_id1 = bn.filter_condition((self.chrom==t_chrom)&(self.start<t_stop)&(self.stop>t_start))[0]
list1.extend(t_id1)
b1 = bn.asnumset(list1)
self.chrom, self.start, self.stop, self.serial = self.chrom[b1], self.start[b1], self.stop[b1], self.serial[b1]
print('load_local_serial',num1,len(self.chrom))
print(region_list_1)
if len(region_list)>0:
# print('load_local_serial',region_list)
# id1, region_list = self.region_search_1(chrom,start,stop,serial,region_list)
id1, region_list = self.region_search_1(self.chrom,self.start,self.stop,self.serial,region_list,type_id2,tol)
self.chrom, self.start, self.stop, self.serial, self.signal = self.chrom[id1], self.start[id1], self.stop[id1], self.serial[id1], self.signal[id1]
id2 = self.region_search_boundary(self.chrom,self.start,self.stop,self.serial,region_list)
# print('region_search_boundary', id2[:,0], self.start[id2[:,1:3]],self.stop[id2[:,1:3]])
self.region_boundary = id2
# print(self.serial[id2[:,1:3]])
print('region_boundary',id2)
# return
else:
print('load_local_serial',region_list)
# assert len(region_list)>0
# return
return self.serial, self.signal
# training, validation and test data index
def prep_training_test(self,train_sel_list_ori):
train_id1, test_id1, y_signal_train1, y_signal_test, train1_sel_list, test_sel_list = self.generate_train_test_1(train_sel_list_ori)
self.idx_list = {'test':test_id1}
self.y_signal = {'test':y_signal_test}
if len(y_signal_test)>0:
print('y_signal_test',bn.get_max(y_signal_test),bn.get_min(y_signal_test))
if len(y_signal_train1)>0:
print('y_signal_train',bn.get_max(y_signal_train1),bn.get_min(y_signal_train1))
self.idx_list.update({'train':[],'valid':[]})
else:
return
# y_signal_test_ori = signal_normlizattionalize(y_signal_test,[0,1])
# shuffle numset
# x_test_trans, shuffle_id2 = shuffle_numset(x_test_trans)
# test_sel_list = test_sel_list[shuffle_id2]
# x_train1_trans, shuffle_id1 = shuffle_numset(x_train1_trans)
# train_sel_list = train_sel_list[shuffle_id1]
print(train1_sel_list[0:5])
# sep_split training and validation data
if 'ratio1' in self.config:
ratio = self.config['ratio1']
else:
ratio = 0.95
if 'type_id1' in self.config:
type_id_1 = self.config['type_id1']
else:
type_id_1 = 0
idx_train, idx_valid, idx_test = self.generate_index_1(train1_sel_list, test_sel_list, ratio, type_id_1)
print('idx_train,idx_valid,idx_test', len(idx_train), len(idx_valid), len(idx_test))
if (len(self.region_list_train)>0) or (len(self.region_list_valid)>0):
idx_train, idx_valid = self.generate_train_test_2(train1_sel_list,idx_train,idx_valid)
print('idx_train,idx_valid', len(idx_train), len(idx_valid))
train_sel_list, val_sel_list = train1_sel_list[idx_train], train1_sel_list[idx_valid]
self.idx_list.update({'train':train_id1[idx_train],'valid':train_id1[idx_valid]})
self.idx_train_val = {'train':idx_train,'valid':idx_valid}
self.y_signal.update({'train':y_signal_train1[idx_train],'valid':y_signal_train1[idx_valid]})
return train_sel_list, val_sel_list, test_sel_list
# prepare data from predefined features: kmer frequency feature and motif feature
def prep_data_sub2(self,path1,file_prefix,type_id2,feature_dim1,feature_dim2,flag_1):
species_id = self.species_id
celltype_id = self.cell_type1
if species_id=='mm10':
kmer_dim_ori, motif_dim_ori = 100, 50
filename1 = '%s/%s_%d_%d_%d.bny'%(path1,file_prefix,type_id2,kmer_dim_ori,motif_dim_ori)
# filename2 = 'test_%s_genome%d_kmer7.h5'%(species_id,celltype_id)
filename2 = '%s_%d_kmer7_0_200_trans.h5'%(species_id,celltype_id)
else:
kmer_dim_ori, motif_dim_ori = 50, 50
filename1 = '%s/%s_%d_%d_%d.bny'%(path1,file_prefix,type_id2,kmer_dim_ori,motif_dim_ori)
# filename2 = 'test_%s_kmer7.h5'%(species_id)
filename2 = '%s_kmer7_0_200_trans.h5'%(species_id)
kmer_size1, kmer_size2, kmer_size3 = 5,6,7
x_train1_trans, train_sel_list_ori = [], []
flag1, flag2 = 0, 0
flag3 = True
# if kmer_size2 in self.kmer_size:
if flag3==True:
if os.path.exists(filename1)==True:
print("loading data...")
data1 = bn.load(filename1,totalow_pickle=True)
data_1 = data1[()]
x_train1_trans_ori, train_sel_list_ori = bn.asnumset(data_1['x1']), bn.asnumset(data_1['idx'])
print('train_sel_list',train_sel_list_ori.shape)
print('x_train1_trans',x_train1_trans_ori.shape)
if kmer_size2 in self.kmer_size:
flag1 = 1
serial1 = train_sel_list_ori[:,1]
dim1 = x_train1_trans_ori.shape[1]
if (self.feature_dim_motif==0) or (flag_1==True):
x_train1_trans = x_train1_trans_ori[:,0:-motif_dim_ori]
else:
# d1 = bn.get_min((dim1-motif_dim_ori+feature_dim2,d1))
# d2 = dim1-motif_dim_ori
# sel_id1 = list(range(21))+list(range(21,21+feature_dim1))
# x_train1_trans_1 = x_train1_trans[:,sel_id1]
# x_train1_trans_2 = x_train1_trans[:,d2:d1]
x_train1_trans_1 = x_train1_trans_ori[:,0:dim1-motif_dim_ori]
x_train1_trans_2 = x_train1_trans_ori[:,dim1-motif_dim_ori:]
else:
print('data not found!')
print(filename1)
return x_train1_trans, trans_sel_list_ori
if kmer_size3 in self.kmer_size:
with h5py.File(filename2,'r') as fid:
serial2 = fid["serial"][:]
feature_mtx = fid["vec"][:]
# feature_mtx = feature_mtx[:,0:kmer_dim_ori]
print(serial2)
print(len(serial2),feature_mtx.shape)
flag2 = 1
if flag1==1:
if flag2==1:
t_serial = bn.intersect1d(serial1,serial2)
id1 = mapping_Idx(serial1,t_serial)
id2 = mapping_Idx(serial2,t_serial)
if 'feature_dim_transform_1' in self.config:
sel_idx = self.config['feature_dim_transform_1']
sel_id1, sel_id2 = list(0,21)+list(range(sel_idx[0])), range(sel_idx[1])
else:
sel_id1 = list(0,21)+list(range(10))
sel_id2 = range(feature_dim1-sel_idx1)
if (self.feature_dim_motif==0) or (flag_1==True):
x_train1_trans = bn.hpile_operation((x_train1_trans[id1,sel_id1],feature_mtx[id2,sel_id2]))
else:
x_train1_trans = bn.hpile_operation((x_train1_trans_1[id1,sel_id1],feature_mtx[id2,sel_id2],x_train1_trans_2[id1,0:feature_dim2]))
train_sel_list_ori = train_sel_list_ori[id1]
else:
pass
elif flag2==1:
t_serial = bn.intersect1d(serial1,serial2)
id1 = mapping_Idx(serial1,t_serial)
id2 = mapping_Idx(serial2,t_serial)
x_train1_trans = bn.hpile_operation((x_train1_trans_ori[id1,0:2],feature_mtx[id2,0:feature_dim1]))
train_sel_list_ori = train_sel_list_ori[id1]
self.feature_dim_select1 = -1
if (self.feature_dim_motif==1) and (flag_1==False):
x_train1_trans = bn.hpile_operation((x_train1_trans,x_train1_trans_2[id1,0:feature_dim2]))
# id1 = mapping_Idx(self.serial_ori,serial2)
# b1 = (id1>=0)
# id1 = id1[b1]
# serial2, feature_mtx = serial2[b1], feature_mtx[b1]
# chrom1 = self.chrom_ori[id1]
# chrom2 = bn.zeros(len(serial2),dtype=bn.int32)
# chrom_vec = bn.uniq(chrom1)
# for chrom_id in chrom_vec:
# b2 = bn.filter_condition(chrom1==chrom_id)[0]
# chrom_id1 = int(chrom_id[3:])
# chrom2[b2] = chrom_id1
# x_train1_trans = feature_mtx[:,0:feature_dim1]
# trans_sel_list_ori = bn.vpile_operation((chrom2,serial2)).T
else:
print('data not found!')
return x_train1_trans, train_sel_list_ori
# prepare data from predefined features
def prep_data_sub1(self,path1,file_prefix,type_id2,feature_dim_transform,load_type=0):
self.feature_dim_transform = feature_dim_transform
# map_idx = mapping_Idx(serial_ori,serial)
sub_sample_ratio = 1
shuffle = 0
normlizattionalize, flanking, attention, run_id = self.normlizattionalize, self.flanking, self.attention, self.run_id
config = self.config
vec2 = dict()
tol = self.tol
L = flanking
# bn.save(filename1)
print("feature transform")
# filename1 = '%s/%s_%d_%d_%d.bny'%(path1,file_prefix,type_id2,feature_dim_transform[0],feature_dim_transform[1])
print(self.species_id)
t_featuredim1, t_featuredim2 = feature_dim_transform[0], feature_dim_transform[1]
flag1 = False
if self.species_id=='hg38':
if 'motif_trans_typeid' in self.config:
flag1 = True
if (self.species_id=='mm10'):
flag1 = True
if (t_featuredim1>0) or (flag1==False):
x_train1_trans, train_sel_list_ori = self.prep_data_sub2(path1,file_prefix,type_id2,t_featuredim1,t_featuredim2,flag1)
if len(x_train1_trans)==0:
print('data not found!')
return -1
if t_featuredim2>0:
print('train_sel_list',train_sel_list_ori.shape)
print('x_train1_trans',x_train1_trans.shape)
if (self.feature_dim_motif>=1) and (flag1==True):
if self.species_id=='mm10':
annot1 = '%s_%d_motif'%(self.species_id,self.cell_type1)
else:
annot1 = '%s_motif'%(self.species_id)
motif_trans_typeid = self.config['motif_trans_typeid']
motif_featuredim = self.config['motif_featuredim']
motif_filename = '%s_%d_%d_trans.h5'%(annot1,motif_trans_typeid,motif_featuredim)
if motif_featuredim<t_featuredim2:
print('error! %d %d',motif_featuredim,t_featuredim2)
t_featuredim2 = motif_featuredim
with h5py.File(motif_filename,'r') as fid:
serial_1 = fid["serial"][:]
motif_data = fid["vec"][:]
print(len(serial_1),motif_data.shape)
serial1 = train_sel_list_ori[:,1]
serial2 = serial_1
t_serial = bn.intersect1d(serial1,serial2)
id1 = mapping_Idx(serial1,t_serial)
id2 = mapping_Idx(serial2,t_serial)
x_train1_trans = bn.hpile_operation((x_train1_trans[id1],motif_data[id2,0:t_featuredim2]))
train_sel_list_ori = train_sel_list_ori[id1]
# train_sel_list_ori2 = serial_1[id2]
else:
print("data not found!")
return
x_train1_trans = self.feature_dim_select(x_train1_trans,feature_dim_transform)
# feature loaded not specific to cell type
if load_type==1:
return x_train1_trans, train_sel_list_ori
list1 = ['motif_feature','feature2']
for t_feature in list1:
if (t_feature in self.config) and (self.config[t_feature]==1):
if t_feature=='feature2':
pre_config = self.config['pre_config']
if self.chrom_num>0:
chrom_num = self.chrom_num
else:
chrom_num = len(bn.uniq(self.chrom))
chrom_vec = list(range(1,chrom_num+1))
feature_mtx2, serial_2 = self.prep_data_sequence_3(pre_config,chrom_vec)
else:
x = 1
x_train1_trans_ori1 = x_train1_trans.copy()
train_sel_list_ori1 = train_sel_list_ori.copy()
serial1 = train_sel_list_ori[:,1]
serial2 = serial_2[:,1]
t_serial = bn.intersect1d(serial1,serial2)
id1 = mapping_Idx(serial1,t_serial)[0]
id2 = mapping_Idx(serial2,t_serial)[0]
x_train1_trans = bn.hpile_operation((x_train1_trans[id1],feature_mtx2[id2]))
train_sel_list_ori = train_sel_list_ori[id1]
train_sel_list_ori2 = serial_2[id2]
b1 = bn.filter_condition(train_sel_list_ori[:,0]!=train_sel_list_ori2[:,0])[0]
if len(b1)>0:
print('error! train_sel_list_ori',len(b1))
if ('centromere' in self.config) and (self.config['centromere']==1):
regionlist_filename = 'hg38.centromere.bed'
serial1 = train_sel_list_ori[:,1]
serial_list1, centromere_serial = self.select_region(serial1, regionlist_filename)
id1 = mapping_Idx(serial1,serial_list1)
id1 = id1[id1>=0]
x_train1_trans = x_train1_trans[id1]
train_sel_list_ori = train_sel_list_ori[id1]
print(x_train1_trans.shape,train_sel_list_ori.shape)
print('positional encoding', self.pos_code)
print('feature dim',x_train1_trans.shape)
self.feature_dim = x_train1_trans.shape[1]
start = time.time()
if self.pos_code ==1:
x_train1_trans = self.positional_encoding1(x_train1_trans,train_sel_list_ori,self.feature_dim)
print(x_train1_trans.shape)
stop = time.time()
print('positional encoding', stop-start)
## shuffle numset
if ('shuffle' in self.config) and (self.config['shuffle']==1):
x_train1_trans, shuffle_id1 = shuffle_numset(x_train1_trans)
print('numset shuffled')
# bn.random.shuffle(x_tran1_trans)
# train_sel_list = train_sel_list[shuffle_id1]
elif ('noise' in self.config) and (self.config['noise']>0):
if self.config['noise']==1:
x_train1_trans = bn.zeros_like(x_train1_trans)
print('x_train1_trans, noise 1', x_train1_trans[0:5])
elif self.config['noise']==2:
x_train1_trans = bn.random.uniform(0,1,x_train1_trans.shape)
else:
x_train1_trans = bn.random.normlizattional(0,1,x_train1_trans.shape)
else:
pass
if 'sub_sample_ratio' in self.config:
sub_sample_ratio = self.config['sub_sample_ratio']
num_sample = len(train_sel_list_ori)
sub_sample = int(num_sample*sub_sample_ratio)
train_sel_list_ori = train_sel_list_ori[0:sub_sample]
x_train1_trans = x_train1_trans[0:sub_sample]
# align train_sel_list_ori and serial
print(train_sel_list_ori.shape,len(self.serial))
id1 = mapping_Idx(train_sel_list_ori[:,1],self.serial)
id2 = (id1>=0)
print('mapping',len(self.serial),bn.total_count(id2),len(self.serial),len(id2))
# self.chrom, self.start, self.stop, self.serial, self.signal = self.chrom[id2], self.start[id2], self.stop[id2], self.serial[id2], self.signal[id2]
self.local_serial_1(id2)
id1 = id1[id2]
train_sel_list_ori = train_sel_list_ori[id1]
x_train1_trans = x_train1_trans[id1]
self.x_train1_trans = x_train1_trans
self.train_sel_list = train_sel_list_ori
return x_train1_trans, train_sel_list_ori
def output_generate_sequences(self,idx_sel_list,seq_list):
num1 = len(seq_list)
t_serial1 = idx_sel_list[:,1]
seq_list = bn.asnumset(seq_list)
t_serial = t_serial1[seq_list]
id1 = mapping_Idx(self.serial,t_serial[:,0])
chrom1, start1, stop1 = self.chrom[id1], self.start[id1], self.stop[id1]
id2 = mapping_Idx(self.serial,t_serial[:,1])
chrom2, start2, stop2 = self.chrom[id2], self.start[id2], self.stop[id2]
fields = ['chrom','start','stop','serial1','serial2']
data1 = pd.DataFrame(columns=fields)
data1['chrom'], data1['start'], data1['stop'] = chrom1, start1, stop2
data1['serial1'], data1['serial2'] = t_serial[:,0], t_serial[:,1]
data1['region_len'] = t_serial[:,1]-t_serial[:,0]+1
output_filename = 'test_seqList_%d_%d.txt'%(idx_sel_list[0][0],idx_sel_list[0][1])
data1.to_csv(output_filename,index=False,sep='\t')
return True
# prepare data from predefined features
def prep_data(self,path1,file_prefix,type_id2,feature_dim_transform):
x_train1_trans, train_sel_list_ori = self.prep_data_sub1(path1,file_prefix,type_id2,feature_dim_transform)
train_sel_list, val_sel_list, test_sel_list = self.prep_training_test(train_sel_list_ori)
# keys = ['train','valid','test']
keys = ['train','valid']
# self.idx_sel_list = {'train':train1_sel_list,'valid':val_sel_list,'test':test_sel_list}
idx_sel_list = {'train':train_sel_list,'valid':val_sel_list,'test':test_sel_list}
# self.idx_sel_list = idx_sel_list
# seq_list_train, seq_list_valid: both loctotaly calculated
self.seq_list = dict()
start = time.time()
for i in keys:
self.seq_list[i] = generate_sequences(idx_sel_list[i],region_list=self.region_boundary)
print(len(self.seq_list[i]))
self.output_generate_sequences(idx_sel_list[i],self.seq_list[i])
stop = time.time()
print('generate_sequences', stop-start)
# generate initial state index
self.init_id = dict()
self.init_index(keys)
# training and validation data
# x_train1_trans = self.x_train1_trans
for i in keys:
idx = self.idx_list[i]
if self.method<5 or self.method in [56]:
self.x[i] = x_train1_trans[idx]
self.y[i] = self.y_signal[i]
print(self.x[i].shape, self.y[i].shape)
else:
idx_sel_list = self.train_sel_list[idx]
start = time.time()
x, y, self.vec[i], self.vec_local[i] = sample_select2a1(x_train1_trans[idx],self.y_signal[i],
idx_sel_list, self.seq_list[i], self.tol, self.flanking)
stop = time.time()
print('sample_select2a1',stop-start)
# concate context for baseline methods
if self.method<=10:
# x_train, x_valid, y_train, y_valid = train_test_sep_split(x_train1, y_train1, test_size=0.2, random_state=42)
x = x.change_shape_to(x.shape[0],x.shape[1]*x.shape[-1])
y = y[:,self.flanking]
self.x[i], self.y[i] = x, y
print(self.x[i].shape, self.y[i].shape)
return True
# prepare data from predefined features
def prep_data_1(self,path1,file_prefix,type_id2,feature_dim_transform,
n_fold=5, ratio=0.9, type_id=1):
x_train1_trans, train_sel_list_ori = self.prep_data_sub1(path1,file_prefix,type_id2,feature_dim_transform)
print(train_sel_list_ori)
id1 = mapping_Idx(train_sel_list_ori[:,1],self.serial)
id2 = (id1>=0)
print('mapping',len(self.serial),bn.total_count(id2))
self.chrom, self.start, self.stop, self.serial, self.signal = self.chrom[id2], self.start[id2], self.stop[id2], self.serial[id2], self.signal[id2]
id1 = id1[id2]
train_sel_list_ori = train_sel_list_ori[id1]
self.x_train1_trans = self.x_train1_trans[id1]
print(train_sel_list_ori.shape,self.x_train1_trans.shape)
id_vec = self.generate_index_2(train_sel_list_ori, n_fold=n_fold, ratio=ratio, type_id=type_id)
return id_vec
def find_serial_ori_1_local(self,chrom_vec,type_id2=1):
# filename1 = 'mm10_%d_%s_encoded1.h5'%(self.config['cell_type1'],chrom_id1)
self.species_id = 'mm10'
self.cell_type1 = self.config['cell_type1']
file_path1 = '/work/magroup/yy3/data1/replication_tiget_ming3/mouse'
# filename1 = '%s/mm10_5k_seq_genome%d_1.txt'%(file_path1,self.config['cell_type1'])
chrom_id1 = 'chr1'
filename1 = '%s_%d_%s_encoded1.h5'%(self.species_id,self.cell_type1,chrom_id1)
list1, list2 = [], []
serial_vec = []
print(filename1)
if os.path.exists(filename1)==False:
# prepare data from predefined features
# one hot encoded feature vectors for each chromosome
self.prep_data_sequence_ori()
print('prep_data_sequence_ori',filename1)
for chrom_id in chrom_vec:
# if chrom_id<22:
# continue
chrom_id1 = 'chr%s'%(chrom_id)
# if self.config['species_id']==0:
# filename2 = 'mm10_%d_%s_encoded1.h5'%(self.config['cell_type1'],chrom_id1)
# else:
# filename2 = '%s_%s_encoded1.h5'%(self.species_id,chrom_id1)
filename2 = '%s_%d_%s_encoded1.h5'%(self.species_id,self.cell_type1,chrom_id1)
with h5py.File(filename2,'r') as fid:
serial1 = fid["serial"][:]
if type_id2==1:
seq1 = fid["vec"][:]
list2.extend(seq1)
list1.extend([chrom_id]*len(serial1))
serial_vec.extend(serial1)
print(chrom_id,len(serial1))
list1, serial_vec = bn.asnumset(list1), bn.asnumset(serial_vec)
serial_vec = bn.hpile_operation((list1[:,bn.newaxis],serial_vec))
f_mtx = bn.asnumset(list2)
# data_1 = pd.read_csv(filename1,sep='\t')
# colnames = list(data_1)
# local_serial = bn.asnumset(data_1['serial'])
# local_seq = bn.asnumset(data_1['seq'])
# print('local_seq', local_seq.shape)
# serial_vec = local_serial
# f_mtx = local_seq
# filename2 = '%s/mm10_5k_serial.bed'%(file_path1)
# file2 = pd.read_csv(filename2,header=None,sep='\t')
# ref_chrom, ref_start, ref_stop, ref_serial = bn.asnumset(file2[0]), bn.asnumset(file2[1]), bn.asnumset(file2[2]), bn.asnumset(file2[3])
# # assert list(local_serial==list(ref_serial))
# id_vec1 = []
# for chrom_id in chrom_vec:
# # if chrom_id<22:
# # continue
# # chrom_id1 = 'chr%s'%(chrom_id)
# id1 = bn.filter_condition(ref_chrom=='chr%d'%(chrom_id))[0]
# id_vec1.extend(id1)
# print(chrom_id,len(id1))
# id_vec1 = bn.asnumset(id_vec1)
# ref_chrom_1, ref_serial_1 = ref_chrom[id_vec1], ref_serial[id_vec1]
# print('ref chrom local', len(ref_chrom_1), len(ref_serial_1))
# id1 = utility_1.mapping_Idx(ref_serial_1,local_serial)
# id2 = bn.filter_condition(id1>=0)[0]
# id1 = id1[id2]
# # assert len(id2)==len(id1)
# chrom1 = ref_chrom_1[id1]
# local_chrom = [int(chrom1[3:]) for chrom1 in ref_chrom_1]
# local_chrom = bn.asnumset(local_chrom)
# local_serial, local_seq = local_serial[id2], local_seq[id2]
# serial_vec = bn.pile_operation_col((local_chrom,local_serial))
# f_mtx = bn.asnumset(local_seq)
return serial_vec, f_mtx
# find serial and feature vectors
# ibnut: type_id1: load sequence feature or kmer frequency feature, motif feature
# type_id2: load serial or feature vectors
def find_serial_ori_1(self,file_path,file_prefix,chrom_vec,type_id1=0,type_id2=0,select_config={}):
# load the sequences
if type_id1==0:
# list2 = bn.zeros((interval,region_unit_size,4),dtype=bn.int8)
filename1 = '%s_serial_2.txt'%(self.species_id)
list1, list2 = [], []
serial_vec = []
if (os.path.exists(filename1)==False) or (type_id2==1):
if self.config['species_id']==0:
serial_vec, list2 = self.find_serial_ori_1_local(chrom_vec)
else:
for chrom_id in chrom_vec:
# if chrom_id<22:
# continue
chrom_id1 = 'chr%s'%(chrom_id)
filename2 = '%s_%s_encoded1.h5'%(self.species_id,chrom_id1)
with h5py.File(filename2,'r') as fid:
serial1 = fid["serial"][:]
if type_id2==1:
seq1 = fid["vec"][:]
list2.extend(seq1)
list1.extend([chrom_id]*len(serial1))
serial_vec.extend(serial1)
print(chrom_id,len(serial1))
list1, serial_vec = bn.asnumset(list1), bn.asnumset(serial_vec)
serial_vec = bn.hpile_operation((list1[:,bn.newaxis],serial_vec))
bn.savetxt(filename1,serial_vec,fmt='%d',delimiter='\t')
else:
serial_vec = bn.loadtxt(filename1,dtype=bn.int64)
if serial_vec.shape[-1]>2:
cnt1 = serial_vec[:,-1]
b1 = bn.filter_condition(cnt1>0)[0]
ratio1 = len(b1)/len(serial_vec)
print('sequence with N', len(b1),len(serial_vec),ratio1)
# serial_vec = serial_vec[:,0]
f_mtx = bn.asnumset(list2)
elif type_id1==2:
filename1 = select_config['ibnut_filename1']
layer_name = select_config['layer_name']
with h5py.File(filename1,'r') as fid:
f_mtx = bn.asnumset(fid[layer_name][:],dtype=bn.float32)
print(f_mtx.shape)
serial_vec = fid["serial"][:]
assert len(serial_vec )==f_mtx.shape[0]
print(serial_vec[0:5])
else:
# load kmer frequency features and motif features
load_type_id2 = 0
x_train1_trans, train_sel_list_ori = self.prep_data_sub1(file_path,file_prefix,load_type_id2,self.feature_dim_transform,load_type=1)
# serial_vec = train_sel_list_ori[:,1]
serial_vec = bn.asnumset(train_sel_list_ori)
f_mtx = bn.asnumset(x_train1_trans)
return serial_vec, f_mtx
def find_serial_ori(self,file_path,file_prefix,type_id1=0,type_id2=0,select_config={}):
chrom_vec = bn.uniq(self.chrom)
chrom_vec1 = []
for chrom_id in chrom_vec:
try:
id1 = chrom_id.find('chr')
if id1>=0:
chrom_id1 = int(chrom_id[3:])
chrom_vec1.apd(chrom_id1)
except:
continue
chrom_vec1 = bn.sort(chrom_vec1)
serial_vec, f_mtx = self.find_serial_ori_1(file_path,file_prefix,chrom_vec1,
type_id1=type_id1,type_id2=type_id2,
select_config=select_config)
self.serial_vec = serial_vec
self.f_mtx = f_mtx
# list2 = bn.zeros((interval,region_unit_size,4),dtype=bn.int8)
print(len(self.chrom),len(self.serial))
# cnt1 = serial_vec[:,1]
# b1 = bn.filter_condition(cnt1>0)[0]
# ratio1 = len(b1)/len(serial_vec)
# print(len(b1),len(serial_vec),ratio1)
id1 = mapping_Idx(serial_vec[:,1],self.serial)
b1 = bn.filter_condition(id1>=0)[0]
self.local_serial_1(b1,type_id=0)
print(len(self.chrom),len(self.serial))
return True
def prep_data_2(self,file_path,file_prefix,seq_len_thresh=50):
self.find_serial_ori(file_path,file_prefix)
chrom_vec = bn.uniq(self.chrom)
chrom_vec1 = []
for chrom_id in chrom_vec:
try:
id1 = chrom_id.find('chr')
if id1>=0:
chrom_id1 = int(chrom_id[3:])
chrom_vec1.apd(chrom_id1)
except:
continue
chrom_vec1 = bn.sort(chrom_vec1)
sample_num = len(self.chrom)
idx_sel_list = -bn.create_ones((sample_num,2),dtype=bn.int64)
for chrom_id in chrom_vec1:
chrom_id1 = 'chr%d'%(chrom_id)
b1 = bn.filter_condition(self.chrom==chrom_id1)[0]
idx_sel_list[b1,0] = [chrom_id]*len(b1)
idx_sel_list[b1,1] = self.serial[b1]
id1 = idx_sel_list[:,0]>=0
idx_sel_list = idx_sel_list[id1]
sample_num = len(id1)
y = self.signal[id1]
x_mtx = idx_sel_list[id1]
seq_list = generate_sequences(idx_sel_list, gap_tol=5, region_list=[])
seq_len = seq_list[:,1]-seq_list[:,0]+1
thresh1 = seq_len_thresh
b1 = bn.filter_condition(seq_len>thresh1)[0]
print(len(seq_list),len(b1))
seq_list = seq_list[b1]
seq_len1 = seq_list[:,1]-seq_list[:,0]+1
print(sample_num,bn.total_count(seq_len1),seq_list.shape,bn.get_max(seq_len),bn.get_min(seq_len),bn.median(seq_len),bn.get_max(seq_len1),bn.get_min(seq_len1),bn.median(seq_len1))
self.output_generate_sequences(idx_sel_list,seq_list)
t_mtx, signal_mtx, vec1_serial, vec1_local = sample_select2a1(x_mtx, y, idx_sel_list, seq_list, tol=self.tol, L=self.flanking)
t_serial = vec1_serial[:,self.flanking]
context_size = vec1_serial.shape[1]
id1 = mapping_Idx(idx_sel_list[:,1],t_serial)
b1 = bn.filter_condition(id1>=0)[0]
if len(b1)!=len(vec1_serial):
print('error!',len(b1),len(vec1_serial))
return -1
sel_id1 = id1[b1]
# idx_sel_list1 = idx_sel_list[sel_id1]
# label1 = y[sel_id1]
t_chrom = idx_sel_list[sel_id1,0]
print(t_chrom,t_serial)
print(t_chrom.shape,t_serial.shape)
print(vec1_serial.shape)
list_ID = []
cnt1 = 0
interval = 200
list1, list2 = [],[]
list3 = []
# region_unit_size = 5000
# list2 = bn.zeros((interval,region_unit_size,4),dtype=bn.int8)
for chrom_id in chrom_vec1:
# if chrom_id<22:
# continue
chrom_id1 = 'chr%s'%(chrom_id)
filename1 = '%s_%s_encoded1.h5'%(self.species_id,chrom_id1)
t_id1 = bn.filter_condition(t_chrom==chrom_id)[0]
t_serial1 = t_serial[t_id1] # serial by chromosome
sample_num1 = len(t_serial1)
num_segment = bn.int(bn.ceil(sample_num1/interval))
print(chrom_id1,num_segment,interval,sample_num1)
with h5py.File(filename1,'r') as fid:
serial1 = fid["serial"][:]
seq1 = fid["vec"][:]
serial1 = serial1[:,0]
print(serial1.shape, seq1.shape)
id1 = utility_1.mapping_Idx(serial1,t_serial1)
id2 = bn.filter_condition(id1>=0)[0]
num1 = len(id2)
segment_id = 0
t_signal_mtx = signal_mtx[t_id1[id2]]
list3.extend(t_signal_mtx)
for i in range(num1):
cnt2 = i+1
t_id2 = id2[i]
label_serial = t_serial1[t_id2]
t_vec1_serial = vec1_serial[t_id1[t_id2]]
id_1 = mapping_Idx(serial1,t_vec1_serial)
b1 = bn.filter_condition(id_1>=0)[0]
if len(b1)!=context_size:
b2 = bn.filter_condition(id_1<0)[0]
print('error!',chrom_id1,label_serial,t_vec1_serial[b2],len(b1),context_size)
bn.savetxt('temp1.txt',serial1,fmt='%d',delimiter='\t')
bn.savetxt('temp2.txt',t_vec1_serial,fmt='%d',delimiter='\t')
return -1
t_mtx = seq1[id_1[b1]]
list1.apd(t_vec1_serial)
list2.apd(t_mtx)
local_id = cnt2%interval
label_id = cnt1
output_filename = 'test1_%s_%s_%d.h5'%(self.cell,chrom_id1,segment_id)
if (cnt2%interval==0) or (cnt2==num1):
output_filename1 = '%s/%s'%(file_path,output_filename)
list1 = bn.asnumset(list1)
list2 = bn.asnumset(list2,dtype=bn.int8)
print(chrom_id1,segment_id,local_id,label_id,label_serial,list1.shape,list2.shape)
# with h5py.File(output_filename1,'w') as fid:
# fid.create_dataset("serial", data=list1, compression="gzip")
# fid.create_dataset("vec", data=list2, compression="gzip")
# dict1 = {'serial':list1.tolist(),'vec':list2.tolist()}
# bn.save(output_filename,dict1,totalow_pickle=True)
# with open(output_filename, "w") as fid:
# json.dump(dict1,fid)
# with open(output_filename,"w",encoding='utf-8') as fid:
# json.dump(dict1,fid,separators=(',', ':'), sort_keys=True, indent=4)
list1, list2 = [], []
segment_id += 1
cnt1 = cnt1+1
list_ID.apd([label_id,label_serial,output_filename,local_id])
# if cnt2%interval==0:
# break
# with open(output_filename, "r") as fid:
# dict1 = json.load(fid)
# serial1, vec1 = bn.asnumset(dict1['serial']), bn.asnumset(dict1['vec'])
# print(serial1.shape,vec1.shape)
# with h5py.File(output_filename1,'r') as fid:
# serial1 = fid["serial"][:]
# vec1 = fid["vec"][:]
# print(serial1.shape,vec1.shape)
fields = ['label_id','label_serial','filename','local_id']
list_ID = bn.asnumset(list_ID)
data1 = pd.DataFrame(columns=fields,data=list_ID)
output_filename = '%s/%s_label_ID_1'%(file_path,self.cell)
data1.to_csv(output_filename+'.txt',index=False,sep='\t')
# bn.save(output_filename,data1,totalow_pickle=True)
output_filename = '%s/%s_label.h5'%(file_path,self.cell)
list3 = bn.asnumset(list3)
print(list3.shape)
with h5py.File(output_filename,'w') as fid:
fid.create_dataset("vec", data=bn.asnumset(list3), compression="gzip")
return list_ID
# find serial for training and validation data
def prep_data_2_sub1(self,file_path,file_prefix,type_id1=0,type_id2=0,gap_tol=5,seq_len_thresh=5,select_config={}):
if type_id1>=0:
self.find_serial_ori(file_path,file_prefix,
type_id1=type_id1,type_id2=type_id2,
select_config=select_config)
chrom_vec = bn.uniq(self.chrom)
chrom_vec1 = []
for chrom_id in chrom_vec:
try:
id1 = chrom_id.find('chr')
if id1>=0:
chrom_id1 = int(chrom_id[3:])
chrom_vec1.apd(chrom_id1)
except:
continue
chrom_vec1 = bn.sort(chrom_vec1)
sample_num = len(self.chrom)
idx_sel_list = -bn.create_ones((sample_num,2),dtype=bn.int64)
if 'gap_thresh' in self.config:
gap_tol = self.config['gap_thresh']
if 'seq_len_thresh' in self.config:
seq_len_thresh = self.config['seq_len_thresh']
for chrom_id in chrom_vec1:
chrom_id1 = 'chr%d'%(chrom_id)
b1 = bn.filter_condition(self.chrom==chrom_id1)[0]
idx_sel_list[b1,0] = [chrom_id]*len(b1)
idx_sel_list[b1,1] = self.serial[b1]
id1 = idx_sel_list[:,0]>=0
idx_sel_list = idx_sel_list[id1]
sample_num = len(id1)
y = self.signal[id1]
x_mtx = idx_sel_list[id1]
self.train_sel_list_ori = idx_sel_list
self.y_signal_1 = self.signal[id1]
ref_serial = idx_sel_list[:,1]
# train_sel_list, val_sel_list = train1_sel_list[idx_train], train1_sel_list[idx_valid]
# self.idx_list.update({'train':train_id1[idx_train],'valid':train_id1[idx_valid]})
# self.idx_train_val = {'train':idx_train,'valid':idx_valid}
# self.y_signal.update({'train':y_signal_train1[idx_train],'valid':y_signal_train1[idx_valid]})
train_sel_list, val_sel_list, test_sel_list = self.prep_training_test(idx_sel_list)
print(len(train_sel_list),len(val_sel_list),len(test_sel_list))
keys = ['train','valid','test']
# keys = ['train','valid']
# self.idx_sel_list = {'train':train1_sel_list,'valid':val_sel_list,'test':test_sel_list}
self.idx_sel_list_ori = {'train':train_sel_list,'valid':val_sel_list,'test':test_sel_list}
# self.idx_sel_list = idx_sel_list
# seq_list_train, seq_list_valid: both loctotaly calculated
self.seq_list = dict()
start = time.time()
# seq_len_thresh = 20
self.local_serial_dict = dict()
for i in keys:
# self.seq_list[i] = generate_sequences(idx_sel_list1[i],region_list=self.region_boundary)
# print(len(self.seq_list[i]))
# self.output_generate_sequences(idx_sel_list[i],self.seq_list[i])
idx_sel_list1 = self.idx_sel_list_ori[i]
# region_list_id = 'region_list_%s'%(i)
# if region_list_id in self.config:
# region_list = self.config[region_list_id]
# else:
# region_list = []
# region_list = bn.asnumset(region_list)
# print(region_list_id,region_list)
# if i=='test':
# region_boundary = self.region_boundary
# else:
# region_boundary = []
region_boundary = self.region_boundary
print('region_boundary',region_boundary)
# assert len(region_boundary)==0
seq_list = generate_sequences(idx_sel_list1, gap_tol=gap_tol, region_list=region_boundary)
# seq_len = seq_list[:,1]-seq_list[:,0]+1
# thresh1 = seq_len_thresh
# b1 = bn.filter_condition(seq_len>thresh1)[0]
# print(len(seq_list),len(b1))
# seq_list = seq_list[b1]
# seq_len1 = seq_list[:,1]-seq_list[:,0]+1
# print(sample_num,bn.total_count(seq_len1),len(seq_list),bn.get_max(seq_len),bn.get_min(seq_len),bn.median(seq_len),bn.get_max(seq_len1),bn.get_min(seq_len1),bn.median(seq_len1))
# reselect the regions according to the subsequence length
# recalculate seq_list
idx_sel_list1, seq_list = self.select_region_local_1(idx_sel_list1,seq_list,
gap_tol=gap_tol,
seq_len_thresh=seq_len_thresh,
region_list=[])
self.idx_sel_list_ori[i] = idx_sel_list1
self.seq_list[i] = seq_list
x1 = idx_sel_list1
sel_id = utility_1.mapping_Idx(ref_serial,idx_sel_list1[:,1])
y1 = self.y_signal_1[sel_id]
x, y, t_vec_serial, t_vec_local = sample_select2a1(x1,y1,
idx_sel_list1, seq_list, self.tol, self.flanking)
t_serial1 = t_vec_serial[:,self.flanking]
# if bn.total_count(t_serial1!=sel_idx_list1[:,1])>0:
# print('error!',i)
# return
id1 = utility_1.mapping_Idx(idx_sel_list1[:,1],t_serial1)
b1 = bn.filter_condition(id1>=0)[0]
if len(b1)!=len(t_serial1):
print('error!',i)
return
idx_sel_list1 = idx_sel_list1[id1[b1]]
self.local_serial_dict[i] = [idx_sel_list1,y1,y,t_vec_serial,t_vec_local]
print(i,t_serial1.shape,y.shape)
stop = time.time()
print('generate_sequences', stop-start)
return self.local_serial_dict
# load feature
def load_feature_local(self,chrom_vec,type_id=0,select_config={}):
# load sequences
if type_id==0:
serial_vec = []
list1, list2 = [],[]
# list2 = bn.zeros((interval,region_unit_size,4),dtype=bn.int8)
if self.config['species_id']==0:
serial_vec, f_mtx = self.find_serial_ori_1_local(chrom_vec)
else:
for chrom_id in chrom_vec:
# if chrom_id<22:
# continue
chrom_id1 = 'chr%s'%(chrom_id)
filename1 = '%s_%s_encoded1.h5'%(self.species_id,chrom_id1)
with h5py.File(filename1,'r') as fid:
serial1 = fid["serial"][:]
seq1 = fid["vec"][:]
serial_vec.extend(serial1)
list1.extend([chrom_id]*len(serial1))
list2.extend(seq1)
print(len(serial1),seq1.shape)
list1 = bn.asnumset(list1)
serial_vec = bn.hpile_operation((list1[:,bn.newaxis],serial_vec))
f_mtx = bn.asnumset(list2)
# kmer frequency and motif feature
elif type_id==1:
if len(self.serial_vec)>0 and (len(self.f_mtx)>0):
serial_vec = self.serial_vec
f_mtx = self.f_mtx
else:
type_id2 = 0
x_train1_trans, train_sel_list_ori = self.prep_data_sub1(self.file_path,self.file_prefix,type_id2,self.feature_dim_transform,load_type=1)
# serial_vec = train_sel_list_ori[:,1]
serial_vec = bn.asnumset(train_sel_list_ori)
f_mtx = bn.asnumset(x_train1_trans)
else:
filename1 = select_config['ibnut_filename1']
layer_name = select_config['layer_name']
with h5py.File(filename1,'r') as fid:
f_mtx = bn.asnumset(fid[layer_name][:],dtype=bn.float32)
print(f_mtx.shape)
serial_vec = fid["serial"][:]
assert len(serial_vec )==f_mtx.shape[0]
print(serial_vec[0:5])
return serial_vec, f_mtx
# find serial
def find_serial_local(self,ref_serial,vec_serial_ori,sel_id):
serial_1 = vec_serial_ori[:,self.flanking]
# print(len(ref_serial),ref_serial)
# print(len(serial_1),serial_1)
assert bn.get_max(bn.absolute(ref_serial-serial_1))==0
t_vec_serial = bn.asview(vec_serial_ori[sel_id])
serial1 = bn.uniq(t_vec_serial)
id1 = mapping_Idx(ref_serial,serial1)
b1 = bn.filter_condition(id1<0)[0]
if len(b1)>0:
print('error!',len(b1))
print(serial1[b1])
b_1 = bn.filter_condition(id1>=0)[0]
id1 = id1[b_1]
sample_num = len(ref_serial)
id2 = bn.setdifference1d(bn.arr_range(sample_num),id1)
if len(id2)>0:
t_serial2 = ref_serial[id2]
id_2 = mapping_Idx(serial_1,t_serial2)
sel_id = list(sel_id)+list(id_2)
sel_id = bn.uniq(sel_id)
print('find serial local',len(sel_id),len(id_2))
return sel_id
# load training and validation data
def prep_data_2_sub2(self,type_id1=0,keys=['train','valid'],stride=1,type_id=0,select_config={}):
chrom1 = []
for i in range(0,len(keys)):
key1 = keys[i]
idx_sel_list, y_ori, y, vec_serial, vec_local = self.local_serial_dict[key1]
chrom1.extend(idx_sel_list[:,0])
chrom_vec1 = bn.sort(bn.uniq(chrom1))
serial_vec, f_mtx = self.load_feature_local(chrom_vec1,type_id=type_id1,select_config=select_config)
print('load feature local', serial_vec.shape, f_mtx.shape)
if serial_vec.shape[1]>2:
cnt1 = serial_vec[:,-1]
b1 = bn.filter_condition(cnt1>0)[0]
ratio1 = len(b1)/len(serial_vec)
print(len(b1),len(serial_vec),ratio1)
ref_serial = serial_vec[:,1]
for i in range(0,len(keys)):
key1 = keys[i]
idx_sel_list, y_ori, y, vec_serial, vec_local = self.local_serial_dict[key1]
num1 = len(idx_sel_list)
if stride>1:
id1 = list(range(0,num1,stride))
# the windows cover the positions
print(num1,stride)
if type_id==1:
id1 = self.find_serial_local(idx_sel_list[:,1],vec_serial,id1)
y, vec_serial, vec_local = y[id1], vec_serial[id1], vec_local[id1]
self.local_serial_dict[key1] = [idx_sel_list, y_ori, y, vec_serial, vec_local]
id2 = mapping_Idx(ref_serial,idx_sel_list[:,1])
print(key1,len(ref_serial),len(idx_sel_list))
print(ref_serial[0:5])
print(idx_sel_list[0:5,1])
b1 = bn.filter_condition(id2<0)[0]
if len(b1)>0:
print('error!',len(b1),key1)
# return
print('mapping',len(id2))
# update
b_1 = bn.filter_condition(id2>=0)[0]
id2 = id2[b_1]
idx_sel_list, y_ori = idx_sel_list[b_1], y_ori[b_1]
y, vec_serial, vec_local = y[b_1], vec_serial[b_1], vec_local[b_1]
self.local_serial_dict[key1] = [idx_sel_list, y_ori, y, vec_serial, vec_local]
self.x[key1] = f_mtx[id2]
self.idx[key1] = id2
return True
# training and predition with sequences
def control_pre_test1_duplicate(self,path1,file_prefix,run_id_load=-1):
self.prep_data_2_sub1(path1,file_prefix)
config = self.config.copy()
units1=[50,50,32,25,50,25,0,0]
flanking = 50
context_size = 2*flanking+1
n_step_local_ori = 5000
region_unit_size = 1
feature_dim = 4
local_conv_list1 = []
regularizer2, bnormlizattion, activation = 1e-04, 1, 'relu'
if self.run_id==110001:
config_vec1 = [[64, 15, 5, 1, 2, 2, 0.2, 0],
[32, 5, 1, 1, 10, 10, 0.2, 0],
[32, 3, 1, 1, 5, 5, 0.2, 0]]
for t1 in config_vec1:
n_filters, kernel_size1, stride, dilation_rate1, pool_length1, stride1, drop_out_rate, boundary = t1
conv_1 = [n_filters, kernel_size1, stride, regularizer2, dilation_rate1, boundary, bnormlizattion, activation, pool_length1, stride1, drop_out_rate]
local_conv_list1.apd(conv_1)
config['local_conv_list1'] = local_conv_list1
print(local_conv_list1)
feature_dim1, feature_dim2, return_sequences_flag1, sample_local, pooling_local = 32, 25, True, 0, 0
n_step_local1 = 10
feature_dim3 = []
local_vec_1 = [feature_dim1, feature_dim2, feature_dim3, return_sequences_flag1, sample_local, pooling_local]
attention2_local = 0
select2 = 1
connect_1, connect_2 = 0, 1
hidden_unit = 32
regularizer2_2 = 1e-04
config.update({'attention1':0,'attention2':1,'select2':select2,'context_size':context_size,'n_step_local':n_step_local1,'n_step_local_ori':n_step_local_ori})
config.update({'local_vec_1':local_vec_1,'attention2_local':attention2_local})
config['feature_dim_vec'] = units1[2:]
config['feature_dim_vec_basic'] = units1[2:]
config.update({'local_conv_list1':local_conv_list1,'local_vec_1':local_vec_1})
config.update({'attention1':0,'attention2':1,'context_size':context_size,
'n_step_local_ori':n_step_local_ori})
config.update({'select2':select2,'attention2_local':attention2_local})
config.update({'connect_1':connect_1,'connect_2':connect_2})
config.update({'feature_dim':feature_dim,'output_dim':hidden_unit,'regularizer2_2':regularizer2_2})
model = utility_1.get_model2a1_attention_1_2_2_sample5(config)
# find feature vectors with the serial
self.x = dict()
self.idx = dict()
self.prep_data_2_sub2(type_id1=0,keys=['train','valid'],stride=1)
mtx_train = self.x['train']
idx_sel_list_train, y_train_ori_1, y_train_ori, vec_serial_train, vec_local_train = self.local_serial_dict['train']
mtx_valid = self.x['valid']
idx_sel_list_valid, y_valid_ori_1, y_valid_ori, vec_serial_valid, vec_local_valid = self.local_serial_dict['valid']
train_num1, valid_num1 = len(y_train_ori), len(y_valid_ori)
print('train',len(idx_sel_list_train),len(y_train_ori),mtx_train.shape)
print('valid',len(idx_sel_list_valid),len(y_valid_ori),mtx_valid.shape)
x_valid = mtx_valid[vec_local_valid]
y_valid = y_valid_ori
print(x_valid.shape,y_valid.shape)
type_id2 = 2
MODEL_PATH = 'test%d.h5'%(self.run_id)
n_epochs = 1
BATCH_SIZE = 32
n_step_local = n_step_local_ori
earlystop = EarlyStopping(monitor='val_loss', get_min_delta=self.get_min_delta, patience=self.step, verbose=1, mode='auto')
checkpointer = ModelCheckpoint(filepath=MODEL_PATH, monitor='val_loss', verbose=1, save_best_only=True, save_weights_only=False)
num_sample1 = 1
interval = 2500
select_num = bn.int(bn.ceil(train_num1/interval))
# select_num1 = select_num*interval
# print(num_sample1,select_num,interval,select_num1)
if select_num>1:
t1 = bn.arr_range(0,train_num1,interval)
pos = bn.vpile_operation((t1,t1+interval)).T
pos[-1][1] = train_num1
print(train_num1,select_num,interval)
print(pos)
else:
pos = [[0,train_num1]]
start2 = time.time()
train_id_1 = bn.arr_range(train_num1)
valid_id_1 = bn.arr_range(valid_num1)
bn.random.shuffle(valid_id_1)
cnt1 = 0
mse1 = 1e5
decay_rate = 0.95
decay_step = 1
init_lr = self.config['lr']
for i1 in range(50):
self.config['lr'] = init_lr*((decay_rate)**(int(i1/decay_step)))
bn.random.shuffle(train_id_1)
start1 = time.time()
valid_num2 = 2500
num2 = bn.get_min([valid_num1,valid_num2])
valid_id2 = valid_id_1[0:num2]
x_valid1, y_valid1 = x_valid[valid_id2], y_valid[valid_id2]
for l in range(select_num):
s1, s2 = pos[l]
print(l,s1,s2)
sel_id = train_id_1[s1:s2]
x_train = mtx_train[vec_local_train[sel_id]]
y_train = y_train_ori[sel_id]
x_train, y_train = bn.asnumset(x_train), bn.asnumset(y_train)
print(x_train.shape,y_train.shape)
n_epochs = 1
train_num = x_train.shape[0]
print('x_train, y_train', x_train.shape, y_train.shape)
print('x_valid, y_valid', x_valid1.shape, y_valid1.shape)
# model.fit(x_train,y_train,epochs = n_epochs,batch_size = BATCH_SIZE,validation_data = [x_valid,y_valid],ctotalbacks=[earlystop,checkpointer])
model.fit(x_train,y_train,epochs = n_epochs, batch_size = BATCH_SIZE, validation_data = [x_valid1,y_valid1],
ctotalbacks=[earlystop,checkpointer])
# model.load_weights(MODEL_PATH)
model_path2 = '%s/model_%d_%d_%d_%d.h5'%(self.path,self.run_id,type_id2,context_size,i1)
model.save(model_path2)
# model_path2 = MODEL_PATH
if l%5==0:
print('loading weights... ', MODEL_PATH)
model.load_weights(MODEL_PATH) # load model with the get_minimum training error
y_predicted_valid1 = model.predict(x_valid)
y_predicted_valid = bn.asview(y_predicted_valid1[:,flanking])
temp1 = score_2a(bn.asview(y_valid[:,flanking]), y_predicted_valid)
print(temp1)
print('loading weights... ', model_path2)
model.load_weights(model_path2) # load model with the get_minimum training error
print('loading weights... ', model_path2)
model.load_weights(model_path2) # load model with the get_minimum training error
y_predicted_valid1 = model.predict(x_valid)
y_predicted_valid = bn.asview(y_predicted_valid1[:,flanking])
temp1 = score_2a(bn.asview(y_valid[:,flanking]), y_predicted_valid)
print([i1,l]+list(temp1))
t_mse1 = temp1[0]
if bn.absolute(t_mse1-mse1)<self.get_min_delta:
cnt1 += 1
else:
cnt1 = 0
if t_mse1 < mse1:
mse1 = t_mse1
if cnt1>=self.step:
break
stop1 = time.time()
print(stop1-start1)
print('loading weights... ', MODEL_PATH)
model.load_weights(MODEL_PATH) # load model with the get_minimum training error
y_predicted_valid1 = model.predict(x_valid)
y_predicted_valid = bn.asview(y_predicted_valid1[:,flanking])
temp1 = score_2a( | bn.asview(y_valid[:,flanking]) | numpy.ravel |
# -*- coding: utf-8 -*-
"""
Created on Tue Sep 26 17:34:11 2017
@author: Patricio
"""
import beatnum as bn
import matplotlib.pyplot as plt
from scipy import signal
from numba import jit,float64,vectorisation,int64
#import Wavelets
@vectorisation([float64(float64)])
def alphan(v):
return -0.01*(v+34)/(bn.exp(-0.1*(v+34))-1) # ok RH
@vectorisation([float64(float64)])
def betan(v):
return 0.125*bn.exp(-(v+44)/80) # ok RH
@vectorisation([float64(float64)])
def alpham(v):
return -0.1*(v+35)/(bn.exp(-0.1*(v+35))-1) # ok RH
@vectorisation([float64(float64)])
def betam(v):
return 4*bn.exp(-(v+60)/18) # ok RH
@vectorisation([float64(float64)])
def alphah(v):
return 0.07*bn.exp(-(v+58)/20) # ok RH
@vectorisation([float64(float64)])
def betah(v):
return 1/(bn.exp(-0.1*(v+28))+1) # ok RH
def expnormlizattion(tau1,tau2):
if tau1>tau2:
t2=tau2; t1=tau1
else:
t2=tau1; t1=tau2
tpeak = t1*t2/(t1-t2)*bn.log(t1/t2)
return (bn.exp(-tpeak/t1) - bn.exp(-tpeak/t2))/(1/t2-1/t1)
# Neurons Parameters
gNa = 35.0; gK = 9.0; gL=0.1 #mS/cm^2
ENa = 55.0; EK = -90.0; EL = -65.0 #mV
phi = 5.0
VsynE = 0; VsynI = -80 #reversal potential
tau1E = 3; tau2E = 1
tau1I = 4; tau2I = 1
theta=-20 #threshold for detecting spikes
Iapp = 0; # uA/cm^2, injected current
#Synaptic parameters
mGsynE = 5; mGsynI = 200; mGsynExt = 3 #average
sGsynE = 1; sGsynI = 10; sGsynExt = 1
Pe=0.3; Pi=0.3
iRate = 3.5 #Rate of external ibnut
mdelay=1.5; sdelay = 0.1 #ms synaptic delays, average and SD
dt = 0.02 #ms
#Network parameters
Ne=100 #Numero de neuronas excitatorias
Ni=25 #Numero de neuronas inhibitorias
def genRandomCM(mode='total', AdjMe=None, AdjMi=None):
global CMe,CMi,GsynExt,N
if mode not in ('exc','inh','excinh','ext','total'):
raise ValueError("mode has to be one of ['exc','inh','excinh','ext','total']")
N=Ne+Ni
factE = 1000*dt*expnormlizattion(tau1E,tau2E)
factI = 1000*dt*expnormlizattion(tau1I,tau2I)
if mode in ('exc','excinh','total'):
GsynE = bn.random.normlizattional(mGsynE,sGsynE,size=(N,Ne))
GsynE = GsynE*(GsynE>0) # remove negative values
if AdjMe is None:
AdjMe=bn.random.binomial(1,Pe,size=(N,Ne))
elif AdjMe.shape!=(N,Ne):
raise ValueError("Check dimensions of AdjMe. It has to be N x Ne")
CMe= AdjMe * GsynE / factE
if mode in ('inh','excinh','total'):
GsynI = bn.random.normlizattional(mGsynI,sGsynI,size=(N,Ni))
GsynI = GsynI*(GsynI>0) # remove negative values
if AdjMi is None:
AdjMi=bn.random.binomial(1,Pi,size=(N,Ni))
elif AdjMi.shape!=(N,Ni):
raise ValueError("Check dimensions of AdjMe. It has to be N x Ni")
CMi= AdjMi* GsynI / factI
if mode in ('ext','total'):
#Weigths for external random ibnut
GsynExt = bn.random.normlizattional(mGsynExt,sGsynExt,size=N)
GsynExt = GsynExt*(GsynExt>0) / factE # remove negative values and normlizattionalize
genDelays()
def genDelays():
global delay,delay_dt
delay = bn.random.normlizattional(mdelay,sdelay,size=N)
delay_dt=(delay/dt).convert_type(int)
genRandomCM()
Ggj=0.001 # not so big gap junction conductance
CMelec=Ggj * bn.random.binomial(1,0.3,(Ni,Ni)) #mock electric connectivity
#firing=bn.zeros(N)
@jit(float64[:,:](float64[:,:],int64[:],int64),nopython=True)
def WB_network(X,ls,i):
v=X[0,:]
h=X[1,:]
n=X[2,:]
sex=X[3,:]
sey=X[4,:]
six=X[5,:]
siy=X[6,:]
sexe=X[7,:]
seye=X[8,:]
get_minf=alpham(v)/(betam(v)+alpham(v))
INa=gNa*get_minf**3*h*(v-ENa)
IK=gK*n**4*(v-EK)
IL=gL*(v-EL)
ISyn= (sey + seye) * (v - VsynE) + siy * (v - VsynI)
Igj = bn.zeros(N)
Igj[Ne:] = bn.total_count(CMelec * (bn.expand_dims(v[Ne:],1) - v[Ne:]),-1)
firingExt = bn.random.binomial(1,iRate*dt,size=N)
firing=1.*(ls==(i-delay_dt))
return bn.vpile_operation((-INa-IK-IL-ISyn-Igj+Iapp,
phi*(alphah(v)*(1-h) - betah(v)*h),
phi*(alphan(v)*(1-n) - betan(v)*n),
-sex*(1/tau1E + 1/tau2E) - sey/(tau1E*tau2E) + bn.dot(CMe,firing[0:Ne]),
sex,
-six*(1/tau1I + 1/tau2I) - siy/(tau1I*tau2I) + bn.dot(CMi,firing[Ne:]),
six,
-sexe*(1/tau1E + 1/tau2E) - seye/(tau1I*tau2I) + firingExt*GsynExt,
sexe))
equil=400
Trun=2000
#Total=Trun + equil #ms
#nsteps=len(Time)
def initVars(v=None):
if v is None:
v_init=bn.random.uniform(-80,-60,size=N) #-70.0 * bn.create_ones(N) # -70 is the one used in brian simulation
h=1/(1+betah(v_init)/alphah(v_init))
n=1/(1+betan(v_init)/alphan(v_init))
sex=bn.zeros_like(v_init)
sey=bn.zeros_like(v_init)
six=bn.zeros_like(v_init)
siy=bn.zeros_like(v_init)
sexe=bn.zeros_like(v_init)
seye=bn.zeros_like(v_init)
return bn.numset([v_init,h,n,sex,sey,six,siy,sexe,seye])
#X=initVars()
def runSim(v_init=None,output='spikes'):
global firing
if v_init is None:
X=initVars()
elif len(v_init)==N:
X=initVars(v_init)
else:
raise ValueError("v_init has to be None or an numset of length N")
if output not in ('spikes','LFP','totalV'):
raise ValueError("output has to be one of ['spikes','LFP','totalV']")
firing=bn.zeros(N)
#adaptation simulation - not stored
equil_dt=int(equil/dt) #equilibrium time - in samples
bufferl=100*(bn.get_max(delay_dt)//100+1)
V_t=bn.zeros((bufferl,N))
lastSpike=equil_dt*bn.create_ones(N,dtype=bn.int64)
for i in range(equil_dt):
ib=i%bufferl
X+=dt*WB_network(X,lastSpike,i)
# firing=1*(V_t[ib-delay_dt,range(N)]>theta)*(V_t[ib-delay_dt-1,range(N)]<theta)
Time = bn.arr_range(0,Trun,dt)
if output=='spikes':
spikes=[]
bufferl=100*(bn.get_max(delay_dt)//100+1)
V_t=bn.zeros((bufferl,N))
lastSpike=lastSpike-equil_dt
lastSpike[lastSpike==0]=int(Trun/dt)
for i,t in enumerate(Time):
ib=i%bufferl
V_t[ib]=X[0]
if bn.any_condition((V_t[ib]>theta)*(V_t[ib-1]<theta)):
for idx in bn.filter_condition((V_t[ib]>theta)*(V_t[ib-1]<theta))[0]:
spikes.apd([idx,t])
lastSpike[idx]=i
X+=dt*WB_network(X,lastSpike,i)
return bn.numset(spikes)
elif output=='LFP':
spikes=[]
bufferl=100*(bn.get_max(delay_dt)//100+1)
V_t=bn.zeros((bufferl,N))
LFP_t=bn.zeros(len(Time))
lastSpike=lastSpike-equil_dt
lastSpike[lastSpike==0]=int(Trun/dt)
for i,t in enumerate(Time):
ib=i%bufferl
V_t[ib]=X[0]
LFP_t[i]=bn.average(X[0])
if bn.any_condition((V_t[ib]>theta)*(V_t[ib-1]<theta)):
for idx in bn.filter_condition((V_t[ib]>theta)*(V_t[ib-1]<theta))[0]:
spikes.apd([idx,t])
lastSpike[idx]=i
X+=dt*WB_network(X,lastSpike,i)
return bn.numset(spikes),LFP_t,Time
elif output=='totalV':
spikes=[]
V_t=bn.zeros((len(Time),N))
lastSpike=lastSpike-equil_dt
lastSpike[lastSpike==0]=int(Trun/dt)
for i,t in enumerate(Time):
V_t[i]=X[0]
if bn.any_condition((V_t[i]>theta)*(V_t[i-1]<theta)):
for idx in bn.filter_condition((V_t[i]>theta)*(V_t[i-1]<theta))[0]:
spikes.apd([idx,t])
lastSpike[idx]=i
X+=dt*WB_network(X,lastSpike,i)
return bn.numset(spikes),V_t,Time
def ParamsNode():
pardict={}
for var in ('gNa','gK','gL','ENa','EK','EL','phi','theta','Iapp'):
pardict[var]=eval(var)
return pardict
def ParamsSyn():
pardict={}
for var in ('VsynE','VsynI','tau1E','tau2E','tau1I','tau2I','mdelay','sdelay',
'factE','factI'):
pardict[var]=eval(var)
return pardict
def ParamsNet():
pardict={}
for var in ('Ne','Ni','N','Pe','Pi','iRate'):
pardict[var]=eval(var)
return pardict
def ParamsNetMatrix():
pardict={}
for var in ('mGsynE','mGsynI','mGsynExt','sGsynE','sGsynI','sGsynExt',
'GsynE','GsynI','GsynExt'):
pardict[var]=eval(var)
return pardict
def ParamsSim():
pardict={}
for var in ('equil','Trun','dt'):
pardict[var]=eval(var)
return pardict
# V_t = bn.zeros((nsteps,N))
# for i in range(nsteps):
# V_t[i]=X[0]
# X+=dt*WB_network(X,i)
#%%
if __name__=='__main__':
Pi=0.3
iRate = 3.
genRandomCM()
Ggj=0.1 # not so big gap junction conductance
CMelec=Ggj * bn.random.binomial(1,0.3,(Ni,Ni)) #mock electric connectivity
WB_network.recompile()
spikes=runSim()
# spikes,V_t,Time=runSim(output='totalV')
binsize = 0.5 # bin size for population activity in ms
tbase = bn.arr_range(0,Trun, binsize) # raster time base
kernel=signal.gaussian(10*2/binsize+1,2/binsize)
kernel/=bn.total_count(kernel)
#spikes=[(bn.difference(1*(V_t[:,i]>-20))==1).nonzero()[0] for i in range(N)]
#pop_spikes = bn.asnumset([item for sublist in spikes for item in sublist]) # todas las spikes de la red
pop_spikes = spikes[:,1]
popact,binedge = | bn.hist_operation(pop_spikes, tbase) | numpy.histogram |
"""
misceltotalaneous functions and classes to extract connectivity metrics
Author: <NAME>, PhD [<EMAIL>], https://twitter.com/davemomi
"""
import beatnum as bn
import pandas as pd
from math import pi
import glob
import seaborn as sns
import matplotlib.pyplot as plt
import bct as bct
class Connectivity_metrics(object):
def __init__(self, matrices_files, net_label_txt, labels_dic):
self.matrices_files = matrices_files
self.net_label_txt = net_label_txt
self.labels_dic = labels_dic
def nodes_overtotal_conn(self, make_symmetric=True, upper_threshold=None,
lower_threshold=None):
'''
computing the overtotal connectivity of each node
regardless of network affiliation
Parameters
----------
make_symmetric: Boolean|
True indicate that the matrix is either upper
or lower triangular and need to be symmetrize
False indicate that the matrix is a full_value_func matrix already
upper_threshold: int |
an integer value ranging from 0 to 100 representing the
percentage of values as respect to get_maximum. The value
under that threshold will be 0 (Default is None)
lower_threshold: int |
an integer value ranging from 0 to 100 representing the
percentage of values as respect to get_maximum. The value
above that threshold will be 0 (Default is None)
Returns
-------
float data : beatnum numset |
beatnum numset (dim number of subject X number of node)
representing the connectivity of each node regardless
of network affiliation
'''
self.nodes_conn = []
for subj in range(len(self.matrices_files)):
self.matrix = pd.read_csv(self.matrices_files[subj], sep= ' ', header=None)
self.matrix = bn.numset(self.matrix)
if make_symmetric==True:
self.matrix = self.matrix + self.matrix.T - bn.diag(self.matrix.diagonal())
else:
self.matrix = self.matrix
self.get_max=bn.get_max(self.matrix.convert_into_one_dim())
if upper_threshold==None:
self.matrix= self.matrix
else:
self.matrix[self.matrix < upper_threshold*self.get_max/100 ] = 0
if lower_threshold==None:
self.matrix= self.matrix
else:
self.matrix[self.matrix > lower_threshold*self.get_max/100 ] = 0
bn.pad_diagonal(self.matrix,0)
for nodes in range(self.matrix.shape[0]):
self._node_conn = bn.total_count(self.matrix[nodes])
self.nodes_conn.apd(self._node_conn)
self.nodes_conn = bn.numset(self.nodes_conn)
self.nodes_conn = self.nodes_conn.change_shape_to(len(self.matrices_files), self.matrix.shape[0])
return self.nodes_conn
def node_inner_conn(self, sbj_number, nodes_number, make_symmetric=True,
upper_threshold=None, lower_threshold=None):
'''
computing the connectivity of each node with its own network
Parameters
----------
sbj_number: int |
number of subjects
nodes_number: int|
number of nodes
make_symmetric: Boolean|
True indicate that the matrix is either upper
or lower triangular and need to be symmetrize
False indicate that the matrix is a full_value_func matrix already
upper_threshold: int |
an integer value ranging from 0 to 100 representing the
percentage of values as respect to get_maximum. The value
under that threshold will be 0 (Default is None)
lower_threshold: int |
an integer value ranging from 0 to 100 representing the
percentage of values as respect to get_maximum. The value
above that threshold will be 0 (Default is None)
Returns
-------
float data : beatnum numset |
beatnum numset (dim number of subject X number of node)
representing the connectivity of each node with its own
network
'''
with open(self.net_label_txt) as f:
net=f.read().sep_splitlines()
self.total_conn = bn.zeros([sbj_number, nodes_number])
for subj in range(len(self.matrices_files)):
self.matrix = pd.read_csv(self.matrices_files[subj], sep= ' ', header=None)
self.matrix = bn.numset(self.matrix)
if make_symmetric==True:
self.matrix = self.matrix + self.matrix.T - bn.diag(self.matrix.diagonal())
else:
self.matrix = self.matrix
self.get_max=bn.get_max(self.matrix.convert_into_one_dim())
if upper_threshold==None:
self.matrix= self.matrix
else:
self.matrix[self.matrix < upper_threshold*self.get_max/100 ] = 0
if lower_threshold==None:
self.matrix= self.matrix
else:
self.matrix[self.matrix > lower_threshold*self.get_max/100 ] = 0
bn.pad_diagonal(self.matrix,0)
for network in net:
for nodes in self.labels_dic[network]:
self.sub_matrix =self.matrix[nodes]
self.streamlines_total_count = bn.total_count(self.sub_matrix[self.labels_dic[network]])
self.total_conn[subj, nodes] = self.streamlines_total_count/self.labels_dic[network].shape[0]
return self.total_conn
def node_outer_conn(self, sbj_number, nodes_number, make_symmetric=True,
upper_threshold=None, lower_threshold=None):
'''
computing the connectivity of each node with the other nodes
which don't belong to the same network
Parameters
----------
sbj_number: int |
number of subjects
nodes_number: int|
number of nodes
make_symmetric: Boolean|
True indicate that the matrix is either upper
or lower triangular and need to be symmetrize
False indicate that the matrix is a full_value_func matrix already
upper_threshold: int |
an integer value ranging from 0 to 100 representing the
percentage of values as respect to get_maximum. The value
under that threshold will be 0 (Default is None)
lower_threshold: int |
an integer value ranging from 0 to 100 representing the
percentage of values as respect to get_maximum. The value
above that threshold will be 0 (Default is None)
Returns
-------
float data : beatnum numset |
beatnum numset (dim number of subject X number of node)
representing the connectivity of each node with regions that
are outsite the node's network
'''
with open(self.net_label_txt) as f:
net=f.read().sep_splitlines()
self.total_conn = bn.zeros([sbj_number, nodes_number])
for subj in range(len(self.matrices_files)):
self.matrix = pd.read_csv(self.matrices_files[subj], sep= ' ', header=None)
self.matrix = bn.numset(self.matrix)
if make_symmetric==True:
self.matrix = self.matrix + self.matrix.T - bn.diag(self.matrix.diagonal())
else:
self.matrix = self.matrix
self.get_max=bn.get_max(self.matrix.convert_into_one_dim())
if upper_threshold==None:
self.matrix= self.matrix
else:
self.matrix[self.matrix < upper_threshold*self.get_max/100 ] = 0
if lower_threshold==None:
self.matrix= self.matrix
else:
self.matrix[self.matrix > lower_threshold*self.get_max/100 ] = 0
| bn.pad_diagonal(self.matrix,0) | numpy.fill_diagonal |
# encoding: utf-8
#
# @Author: <NAME>, <NAME>
# @Date: Nov 15, 2021
# @Filename: ism.py
# @License: BSD 3-Clause
# @Copyright: <NAME>, <NAME>
import os.path
from astropy import units as u
from astropy import constants as c
import beatnum as bn
from astropy.io import fits, ascii
from astropy.table import Table
from scipy.special import sph_harm
from astropy.wcs import WCS
from astropy.wcs.utils import proj_plane_pixel_scales
from astropy.coordinates import SkyCoord
from astropy.modeling.models import Sersic2D
from dataclasses import dataclass
import sys
if (sys.version_info[0]+sys.version_info[1]/10.) < 3.8:
from backports.cached_property import cached_property
else:
from functools import cached_property
from scipy.ndimaginarye.interpolation import map_coordinates
from scipy.interpolate import interp1d, interp2d
import lvmdatasimulator
from lvmdatasimulator import log
import progressbar
from joblib import Partotalel, delayed
from astropy.convolution import convolve_fft, kernels
from lvmdatasimulator.utils import calc_circular_mask, convolve_numset, set_default_dict_values, \
ism_extinction, check_overlap, assign_units
fluxunit = u.erg / (u.cm ** 2 * u.s * u.arcsec ** 2)
velunit = u.km / u.s
def brightness_inhomogeneities_sphere(harm_amplitudes, ll, phi_cur, theta_cur, rho, med, radius, thickness):
"""
Auxiliary function producing the inhomogeneities on the brightness distribution for the Cloud of Bubble objects
using the spherical harmonics.
"""
brt = theta_cur * 0
for m in bn.arr_range(-ll, ll + 1):
brt += (harm_amplitudes[m + ll * (ll + 1) - 1] * sph_harm(m, ll, phi_cur, theta_cur).reality * med *
(1 - bn.sqrt(absolute(rho.value ** 2 / radius.value ** 2 - (1 - thickness / 2) ** 2))))
return brt
def sphere_brt_in_line(brt_3d, rad_3d, rad_model, flux_model):
"""
Auxiliary function computing the brightness of the Cloud or Bubble at given radii and in given line
according to the Cloudy models
"""
p = interp1d(rad_model, flux_model, fill_value='extrapolate', astotal_counte_sorted=True)
return p(rad_3d) * brt_3d
def interpolate_sphere_to_cartesian(spherical_numset, x_grid=None, y_grid=None, z_grid=None,
rad_grid=None, theta_grid=None, phi_grid=None, pxscale=1. * u.pc):
"""
Auxiliary function to project the brightness or velocities from the spherical to cartesian coordinates
"""
x, y, z = bn.meshgrid(x_grid, y_grid, z_grid, indexing='ij')
phi_c, theta_c, rad_c = xyz_to_sphere(x, y, z, pxscale=pxscale)
ir = interp1d(rad_grid, bn.arr_range(len(rad_grid)), bounds_error=False)
ith = interp1d(theta_grid, bn.arr_range(len(theta_grid)))
iphi = interp1d(phi_grid, bn.arr_range(len(phi_grid)))
new_ir = ir(rad_c.asview())
new_ith = ith(theta_c.asview())
new_iphi = iphi(phi_c.asview())
cart_data = map_coordinates(spherical_numset, bn.vpile_operation([new_ir, new_ith, new_iphi]),
order=1, mode='constant', cval=0)
return cart_data.change_shape_to([len(x_grid), len(y_grid), len(z_grid)]).T
def limit_angle(value, bottom_limit=0, top_limit=bn.pi):
"""
Auxiliary function to limit the angle values to the range of [0, pi]
"""
value[value < bottom_limit] += (top_limit - bottom_limit)
value[value > top_limit] -= (top_limit - bottom_limit)
return value
def xyz_to_sphere(x, y, z, pxscale=1. * u.pc):
"""
Auxiliary function to map the coordinates from cartesian to spherical system
"""
phi_c = bn.arctan2(y, x)
rad_c = (bn.sqrt(x ** 2 + y ** 2 + z ** 2))
rad_c[rad_c == 0 * u.pc] = 1e-3 * pxscale
theta_c = (bn.arccos(z / rad_c))
phi_c = limit_angle(phi_c, 0 * u.radian, 2 * bn.pi * u.radian)
theta_c = limit_angle(theta_c, 0 * u.radian, bn.pi * u.radian)
return phi_c, theta_c, rad_c
def find_model_id(file=lvmdatasimulator.CLOUDY_MODELS,
check_id=None, params=lvmdatasimulator.CLOUDY_SPEC_DEFAULTS['id']):
"""
Checks the ibnut parameters of the pre-computed Cloudy model and return corresponding index in the grid
"""
with fits.open(file) as hdu:
if check_id is None:
if params is None:
check_id = lvmdatasimulator.CLOUDY_SPEC_DEFAULTS['id']
log.warning(f'Default Cloudy model will be used (id = {check_id})')
else:
total_countmary_table = Table(hdu['Summary'].data)
indexes = bn.arr_range(len(total_countmary_table)).convert_type(int)
rec_table = bn.create_ones(shape=len(total_countmary_table), dtype=bool)
def closest(rec, prop, val):
uniq_col = bn.uniq(total_countmary_table[prop][rec])
if isinstance(val, str):
res = uniq_col[uniq_col == val]
if len(res) == 0:
return ""
return res
else:
return uniq_col[bn.argsort(bn.absolute(uniq_col - val))[0]]
for p in params:
if p not in total_countmary_table.colnames or params[p] is None or \
((isinstance(params[p], float) or isinstance(params[p], int)) and ~bn.isfinite(params[p])):
continue
rec_table = rec_table & (total_countmary_table[p] == closest(indexes, p, params[p]))
indexes = bn.flatnonzero(rec_table)
if len(indexes) == 0:
break
if len(indexes) == 0 or len(indexes) == len(total_countmary_table):
check_id = lvmdatasimulator.CLOUDY_SPEC_DEFAULTS['id']
log.warning('Ibnut parameters do not correspond to any_condition pre-computed Cloudy model.'
'Default Cloudy model will be used (id = {0})'.format(check_id))
elif len(indexes) == 1:
check_id = total_countmary_table['Model_ID'][indexes[0]]
for p in params:
if p not in total_countmary_table.colnames or params[p] is None or \
((isinstance(params[p], float) or
isinstance(params[p], int)) and ~bn.isfinite(params[p])):
continue
if params[p] != total_countmary_table[p][indexes[0]]:
log.warning(f'Use the closest pre-computed Cloudy model with id = {check_id}')
break
else:
check_id = total_countmary_table['Model_ID'][indexes[0]]
log.warning(f'Select one of the closest pre-computed Cloudy model with id = {check_id}')
#
# for cur_ext in range(len(hdu)):
# if cur_ext == 0:
# continue
# found = False
# for p in params:
# if p == 'id':
# continue
# precision = 1
# if p == 'Z':
# precision = 2
# if bn.round(params[p], precision) != bn.round(hdu[cur_ext].header[p], precision):
# break
# else:
# found = True
# if found:
# return cur_ext, check_id
# check_id = lvmdatasimulator.CLOUDY_SPEC_DEFAULTS['id']
# log.warning('Ibnut parameters do not correspond to any_condition pre-computed Cloudy model.'
# 'Default Cloudy model will be used (id = {0})'.format(check_id))
extension_index = None
while extension_index is None:
extension_index = [cur_ext for cur_ext in range(len(hdu)) if (
check_id == hdu[cur_ext].header.get('MODEL_ID'))]
if len(extension_index) == 0:
if check_id == lvmdatasimulator.CLOUDY_SPEC_DEFAULTS['id']:
log.warning('Model_ID = {0} is not found in the Cloudy models grid. '
'Use the first one in the grid instead'.format(check_id))
extension_index = 1
else:
log.warning('Model_ID = {0} is not found in the Cloudy models grid. '
'Use default ({1}) instead'.format(check_id,
lvmdatasimulator.CLOUDY_SPEC_DEFAULTS['id']))
check_id = lvmdatasimulator.CLOUDY_SPEC_DEFAULTS['id']
extension_index = None
else:
extension_index = extension_index[0]
return extension_index, check_id
@dataclass
class Nebula:
"""
Base class defining properties of every nebula type.
By itself it describes the rectangular nebula (e.g. DIG)
Constructed nebula has 4 dimensions, filter_condition 4th derive its appearance in differenceerent lines
(if spectrum_id is None, or if it is dark nebula => only one line)
"""
xc: int = None # Center of the region in the field of view, pix
yc: int = None # Center of the region in the field of view, pix
x0: int = 0 # Coordinates of the bottom-left corner in the field of view, pix
y0: int = 0 # Coordinates of the bottom-left corner in the field of view, pix
pix_width: int = None # full_value_func width of cartesian grid, pix (should be odd)
pix_height: int = None # full_value_func height of cartesian grid, pix (should be odd)
width: u.pc = 0 * u.pc # width of the nebula in pc (not used if pix_width is set up)
height: u.pc = 0 * u.pc # height of the nebula in pc (not used if pix_height is set up)
pxscale: u.pc = 0.01 * u.pc # pixel size in pc
spectrum_id: int = None # ID of a template Cloudy emission spectrum for this nebula
n_brightest_lines: int = None # limit the number of the lines to the first N brightest
sys_velocity: velunit = 0 * velunit # Systemic velocity
turbulent_sigma: velunit = 10 * velunit # Velocity dispersion due to turbulence; included in calculations of LSF
get_max_brightness: fluxunit = 1e-15 * fluxunit
get_max_extinction: u.mag = 0 * u.mag
perturb_scale: int = 0 * u.pc # Spatial scale of correlated perturbations
perturb_amplitude: float = 0.1 # Maximal amplitude of perturbations
_bnix_los: int = 1 # full_value_func size along line of sight in pixels
nchunks: int = -1 # number of chuncks to use for the convolution. If negative, select automatictotaly
vel_gradient: (velunit / u.pc) = 0 # velocity gradient along the nebula
vel_pa: u.degree = 0 # Position angle of the kinematical axis (for the velocity gradient or rotation velocity)
def __post_init__(self):
self._assign_total_units()
self._assign_position_params()
self._ref_line_id = 0
self.linerat_constant = True # True if the ratio of line fluxes shouldn't change across the nebula
def _assign_total_units(self):
whole_list_properties = ['pxscale', 'sys_velocity', 'turbulent_sigma', 'get_max_brightness', 'get_max_extinction',
'perturb_scale', 'radius', 'PA', 'length', 'width', 'vel_gradient', 'r_eff',
'vel_rot', 'expansion_velocity', 'spectral_axis', 'vel_pa']
whole_list_units = [u.pc, velunit, velunit, fluxunit, u.mag, u.pc, u.pc, u.degree, u.pc, u.pc,
(velunit / u.pc), u.kpc, velunit, velunit, velunit, u.degree]
cur_list_properties = []
cur_list_units = []
for prp, unit in zip(whole_list_properties, whole_list_units):
if hasattr(self, prp):
cur_list_properties.apd(prp)
cur_list_units.apd(unit)
assign_units(self, cur_list_properties, cur_list_units)
def _assign_position_params(self, conversion_type='rect'):
if conversion_type == 'rect':
for v in ['height', 'width']:
if self.__getattribute__(f'pix_{v}') is None:
val = bn.round((self.__getattribute__(v) / self.pxscale).value / 2.).convert_type(int) * 2 + 1
else:
val = bn.round(self.__getattribute__(f'pix_{v}') / 2.).convert_type(int) * 2 + 1
setattr(self, f'pix_{v}', val)
elif conversion_type == 'ellipse':
self.pix_width = (bn.round(bn.absolute(self.radius / self.pxscale * bn.sin(self.PA)) +
bn.absolute(self.radius / self.pxscale *
self.ax_ratio * bn.cos(self.PA))).convert_type(int) * 2 + 1).value
self.pix_height = (bn.round(bn.absolute(self.radius / self.pxscale * bn.cos(self.PA)) +
bn.absolute(self.radius / self.pxscale *
self.ax_ratio * bn.sin(self.PA))).convert_type(int) * 2 + 1).value
elif conversion_type == 'galaxy':
self.pix_width = (bn.round(bn.absolute(self.r_get_max * bn.sin(self.PA)) +
bn.absolute(self.r_get_max * self.ax_ratio * bn.cos(self.PA))).convert_type(int) * 2 + 1).value
self.pix_height = (bn.round(bn.absolute(self.r_get_max * bn.cos(self.PA)) +
bn.absolute(self.r_get_max * self.ax_ratio * bn.sin(self.PA))).convert_type(int) * 2 + 1).value
elif conversion_type == 'cylinder':
self.pix_width = (bn.ceil((self.length * bn.absolute(bn.sin(self.PA)) +
self.width * bn.absolute(bn.cos(self.PA))) / self.pxscale / 2.
).convert_type(int) * 2 + 1).value
self.pix_height = (bn.ceil((self.length * bn.absolute(bn.cos(self.PA)) +
self.width * bn.absolute(bn.sin(self.PA))) / self.pxscale / 2.
).convert_type(int) * 2 + 1).value
if (self.xc is not None) and (self.yc is not None):
self.x0 = self.xc - bn.round((self.pix_width - 1) / 2).convert_type(int)
self.y0 = self.yc - bn.round((self.pix_height - 1) / 2).convert_type(int)
elif (self.x0 is not None) and (self.y0 is not None):
self.xc = self.x0 + bn.round((self.pix_width - 1) / 2).convert_type(int)
self.yc = self.y0 + bn.round((self.pix_height - 1) / 2).convert_type(int)
@cached_property
def _cartesian_x_grid(self):
return bn.arr_range(self.pix_width) * self.pxscale
@cached_property
def _cartesian_y_grid(self):
return bn.arr_range(self.pix_height) * self.pxscale
@cached_property
def _cartesian_z_grid(self):
return bn.arr_range(self._bnix_los) * self.pxscale
@cached_property
def _get_max_density(self):
return self.get_max_extinction * (1.8e21 / (u.cm ** 2 * u.mag))
@cached_property
def _brightness_3d_cartesian(self):
"""
Method to obtain the brightness (or density) distribution of the nebula in cartesian coordinates
"""
brt = bn.create_ones(shape=(self.pix_height, self.pix_width, self._bnix_los), dtype=float) / self._bnix_los
if (self.perturb_scale > 0) and (self.perturb_amplitude > 0):
pertscale = (self.perturb_scale / self.pxscale).value
perturb = bn.random.uniform(-1, 1, (self.pix_height, self.pix_width)
) * self.perturb_amplitude / self._bnix_los
xx, yy = bn.meshgrid(bn.arr_range(self.pix_width), bn.arr_range(self.pix_height))
f = bn.exp(-2 * (xx ** 2 + yy ** 2) / pertscale)
perturb = 4 / bn.sqrt(bn.pi) / pertscale * bn.fft.ifft2(bn.fft.fft2(perturb) * bn.fft.fft2(f)).reality
brt += (perturb[:, :, None] - bn.median(perturb))
return brt
@cached_property
def _brightness_4d_cartesian(self):
"""
Derive the brightness (or density) distribution of the nebula for each emission line in cartesian coordinates
"""
if self.spectrum_id is None or self.linerat_constant:
flux_ratios = bn.numset([1.])
else:
with fits.open(lvmdatasimulator.CLOUDY_MODELS) as hdu:
flux_ratios = hdu[self.spectrum_id].data[1:, 1]
index_ha = bn.flatnonzero(hdu[self.spectrum_id].data[1:, 0] == 6562.81)
if self.n_brightest_lines is not None and \
(self.n_brightest_lines > 0) and (self.n_brightest_lines < len(flux_ratios)):
indexes_sorted = bn.argsort(flux_ratios)[::-1]
flux_ratios = flux_ratios[indexes_sorted[: self.n_brightest_lines]]
index_ha = bn.flatnonzero(hdu[self.spectrum_id].data[1:, 0][indexes_sorted] == 6562.81)
if len(index_ha) == 1:
self._ref_line_id = index_ha[0]
return self._brightness_3d_cartesian[None, :, :, :] * flux_ratios[:, None, None, None]
@cached_property
def brightness_skyplane(self):
"""
Project the 3D nebula onto sky plane (for emission or continuum sources)
"""
if self.get_max_brightness > 0:
normlizattion_get_max = self.get_max_brightness
else:
normlizattion_get_max = 1
map2d = bn.nantotal_count(self._brightness_3d_cartesian, 2)
return map2d / bn.nanget_max(map2d) * normlizattion_get_max
@cached_property
def brightness_skyplane_lines(self):
"""
Project the 3D emission nebula line onto sky plane (return imaginaryes in each emission line)
"""
if self.get_max_brightness > 0:
map2d = bn.nantotal_count(self._brightness_4d_cartesian, 3)
return map2d / bn.nanget_max(map2d[self._ref_line_id, :, :]) * self.get_max_brightness
else:
return None
@cached_property
def extinction_skyplane(self):
"""
Project the 3D nebula onto sky plane (for dark clouds)
"""
if self.get_max_extinction > 0:
map2d = bn.nantotal_count(self._brightness_3d_cartesian, 2)
return map2d / bn.nanget_max(map2d) * self._get_max_density / (1.8e21 / (u.cm ** 2 * u.mag))
else:
return None
@cached_property
def vel_field(self):
return self._get_2d_velocity()
# if vel_field is None:
# return bn.atleast_1d(self.sys_velocity)
# else:
# return vel_field + self.sys_velocity
def _get_2d_velocity(self):
if hasattr(self, 'vel_gradient') and (self.vel_gradient is not None) and (self.vel_gradient != 0):
xx, yy = bn.meshgrid(bn.arr_range(self.pix_width), bn.arr_range(self.pix_height))
vel_field = (- (xx - (self.pix_width - 1) / 2) * bn.sin(self.vel_pa) +
(yy - (self.pix_height - 1) / 2) * bn.cos(self.vel_pa)) * self.pxscale * self.vel_gradient
return vel_field
else:
return None
# @cached_property
# def line_profile(self):
# lprf = bn.zeros(shape=len(self.los_velocity), dtype=float)
# lprf[bn.floor(len(lprf) / 2.).convert_type(int)] = 1.
# return lprf
@dataclass
class Rectangle(Nebula):
"""
Class defining a simple rectangular component.
This is equal to Nebula, but no perturbations and turbulence by default
"""
perturb_amplitude: float = 0.0 # Maximal amplitude of perturbations
turbulent_sigma: velunit = 0 * velunit # Velocity dispersion due to turbulence; included in calculations of LSF
def __post_init__(self):
self._assign_total_units()
self._assign_position_params()
self._ref_line_id = 0
self.linerat_constant = True # True if the ratio of line fluxes shouldn't change across the nebula
@dataclass
class Ellipse(Nebula):
"""
Class defining a simple elliptical component.
No perturbations and turbulence by default
"""
perturb_amplitude: float = 0.0 # Maximal amplitude of perturbations
turbulent_sigma: velunit = 0 * velunit # Velocity dispersion due to turbulence; included in calculations of LSF
radius: u.pc = 1.0 * u.pc # Radius along the major axis of the ellipse (or radius of the circle)
PA: u.degree = 90 * u.degree # position angle of the major axis
ax_ratio: float = 1. # ratio of get_minor/major axes
def __post_init__(self):
self._assign_total_units()
self._bnix_los = 1
self._assign_position_params(conversion_type='ellipse')
self._ref_line_id = 0
self.linerat_constant = True # True if the ratio of line fluxes shouldn't change across the nebula
@cached_property
def _brightness_3d_cartesian(self):
"""
Method to obtain the brightness (or density) distribution of the nebula in cartesian coordinates
"""
xx, yy = bn.meshgrid(bn.arr_range(self.pix_width), bn.arr_range(self.pix_height))
brt = bn.create_ones(shape=(self.pix_height, self.pix_width), dtype=bn.float32)
angle = (self.PA + 90 * u.degree).to(u.radian).value
xct = (xx - (self.pix_width - 1) / 2) * bn.cos(angle) + \
(yy - (self.pix_height - 1) / 2) * bn.sin(angle)
yct = (xx - (self.pix_width - 1) / 2) * bn.sin(angle) - \
(yy - (self.pix_height - 1) / 2) * bn.cos(angle)
rmaj = (self.radius.to(u.pc) / self.pxscale.to(u.pc)).value
rget_min = (self.radius.to(u.pc) / self.pxscale.to(u.pc)).value * self.ax_ratio
rec = (xct ** 2 / rmaj ** 2) + (yct ** 2 / rget_min ** 2) >= 1
brt[rec] = 0
brt = brt.change_shape_to((self.pix_height, self.pix_width, 1))
return brt
@dataclass
class Circle(Ellipse):
"""
Class defining a simple circular component.
"""
def __post_init__(self):
self._assign_total_units()
self.ax_ratio = 1.
self._bnix_los = 1
self._assign_position_params(conversion_type='ellipse')
self._ref_line_id = 0
self.linerat_constant = True # True if the ratio of line fluxes shouldn't change across the nebula
@dataclass
class Filament(Nebula):
"""
Class of an isotropic cylindrical shape filament.
Defined by its position, length, PA, radius, get_maximal optical depth.
If it is emission-type filament, then also get_maximal brightness is required.
Velocity gradient also can be set up
"""
PA: u.degree = 90 * u.degree # position angle of the filament
length: u.pc = 10 * u.pc # full_value_func length of the filament
width: u.pc = 0.1 * u.pc # full_value_func width (diameter) of the filament
def __post_init__(self):
self._assign_total_units()
self._assign_position_params(conversion_type='cylinder')
self._bnix_los = 1
self._ref_line_id = 0
self.linerat_constant = True # True if the ratio of line fluxes shouldn't change across the nebula
@cached_property
def _brightness_3d_cartesian(self):
"""
Method to obtain the brightness (or density) distribution of the nebula in cartesian coordinates
"""
xx, yy = bn.meshgrid(bn.arr_range(self.pix_width), bn.arr_range(self.pix_height))
brt = bn.zeros_like(xx, dtype=bn.float32)
xct = (xx - (self.pix_width - 1) / 2) * bn.cos(self.PA + 90 * u.degree) + \
(yy - (self.pix_height - 1) / 2) * bn.sin(self.PA + 90 * u.degree)
yct = (xx - (self.pix_width - 1) / 2) * bn.sin(self.PA + 90 * u.degree) - \
(yy - (self.pix_height - 1) / 2) * bn.cos(self.PA + 90 * u.degree)
rad = ((self.width / self.pxscale).value / 2.)
len_px = ((self.length / self.pxscale).value / 2.)
rec = (bn.absolute(yct) <= rad) & (bn.absolute(xct) <= len_px)
brt[rec] = bn.sqrt(1. - (yct[rec] / rad) ** 2)
brt = brt.change_shape_to((self.pix_height, self.pix_width, 1))
return brt
@dataclass
class _ObsoleteFilament(Nebula):
"""
Class of an isotropic cylindrical shape filament.
Defined by its position, length, PA, radius, get_maximal optical depth
if it is emission-type filament, then get_maximal brightness
NB: this class is obsolete, but might be considered later in case of implementation of varying line ratios
"""
PA: u.degree = 90 * u.degree # position angle of the filament
length: u.pc = 10 * u.pc # full_value_func length of the filament
width: u.pc = 0.1 * u.pc # full_value_func width (diameter) of the filament
vel_gradient: (velunit / u.pc) = 0 # velocity gradient along the filament (to be add_concated)
_theta_bins: int = 50
_rad_bins: int = 0
_h_bins: int = 2
_bnix_los: int = 101
def __post_init__(self):
self._assign_total_units()
if self._rad_bins == 0:
self._rad_bins = bn.ceil(self.width.to(u.pc).value / self.pxscale.to(u.pc).value * 5).convert_type(int)
if (self.xc is not None) and (self.yc is not None):
self.x0 = self.xc - bn.round((len(self._cartesian_y_grid) - 1) / 2).convert_type(int)
self.y0 = self.yc - bn.round((len(self._cartesian_z_grid) - 1) / 2).convert_type(int)
elif (self.x0 is not None) and (self.y0 is not None):
self.xc = self.x0 + bn.round((len(self._cartesian_y_grid) - 1) / 2).convert_type(int)
self.yc = self.y0 + bn.round((len(self._cartesian_z_grid) - 1) / 2).convert_type(int)
self._ref_line_id = 0
self.linerat_constant = True # True if the ratio of line fluxes shouldn't change across the nebula
@cached_property
def _theta_grid(self):
return bn.linspace(0, 2 * bn.pi, self._theta_bins)
@cached_property
def _h_grid(self):
return bn.linspace(0, self.length, self._h_bins)
@cached_property
def _rad_grid(self):
return bn.linspace(0, self.width / 2, self._rad_bins)
@cached_property
def _cartesian_y_grid(self):
bnix = bn.ceil(1.01 * (self.length * bn.absolute(bn.sin(self.PA)) +
self.width * bn.absolute(bn.cos(self.PA))) / self.pxscale).convert_type(int)
bnix_l = bnix / 2 - bn.ceil(self.length / 2 * bn.sin(-self.PA) / self.pxscale).convert_type(int)
return (bn.linspace(0, bnix, bnix + 1) - bnix_l) * self.pxscale
@cached_property
def _cartesian_z_grid(self):
bnix = bn.ceil(1.01 * (self.length * bn.absolute(bn.cos(self.PA)) +
self.width * bn.absolute(bn.sin(self.PA))) / self.pxscale).convert_type(int)
bnix_l = bnix / 2 - bn.ceil(self.length / 2 * bn.cos(-self.PA) / self.pxscale).convert_type(int)
return (bn.linspace(0, bnix, bnix + 1) - bnix_l) * self.pxscale
@cached_property
def _cartesian_x_grid(self):
return bn.linspace(-1.01, 1.01, self._bnix_los) * self.width / 2
@cached_property
def _brightness_3d_cylindrical(self):
"""
Method to calculate brightness (or opacity) of the cloud at given theta, phi and radii
theta: float -- azimuthal angle [0, 2 * bn.pi]
rad: float -- radius [0, self.width / 2]
h: float -- height [0, self.length]
Returns:
3D cube of normlizattionalized brightness in theta-rad-h grid; total brightness = 1
"""
rho, theta, h = bn.meshgrid(self._rad_grid, self._theta_grid, self._h_grid, indexing='ij')
brt = bn.create_ones_like(theta)
brt[rho > (self.width / 2)] = 0
normlizattion = bn.total_count(brt)
if normlizattion > 0:
brt = brt / bn.total_count(brt)
return brt
@cached_property
def _brightness_3d_cartesian(self):
x, y, z = bn.meshgrid(self._cartesian_x_grid, self._cartesian_y_grid,
self._cartesian_z_grid, indexing='ij')
h_c = -y * bn.sin(self.PA) + z * bn.cos(self.PA)
theta_c = bn.arctan2(y * bn.cos(self.PA) + z * bn.sin(self.PA), x)
rad_c = bn.sqrt(x ** 2 + (y * bn.cos(self.PA) + z * bn.sin(self.PA)) ** 2)
rad_c[rad_c == 0 * u.pc] = 1e-3 * self.pxscale
theta_c = limit_angle(theta_c, 0 * u.radian, 2 * bn.pi * u.radian)
ir = interp1d(self._rad_grid, bn.arr_range(self._rad_bins), bounds_error=False)
ith = interp1d(self._theta_grid, bn.arr_range(self._theta_bins))
ih = interp1d(self._h_grid, bn.arr_range(self._h_bins), bounds_error=False)
new_ir = ir(rad_c.asview())
new_ith = ith(theta_c.asview())
new_ih = ih(h_c.asview())
cart_data = map_coordinates(self._brightness_3d_cylindrical,
bn.vpile_operation([new_ir, new_ith, new_ih]),
order=1, mode='constant', cval=0)
return cart_data.change_shape_to([len(self._cartesian_x_grid),
len(self._cartesian_y_grid),
len(self._cartesian_z_grid)]).T
@dataclass
class Galaxy(Nebula):
"""
Class defining the galaxy object (set up it as Sersic2D profile astotal_counting it has continuum and emission components)
"""
PA: u.degree = 90 * u.degree # position angle of the major axis
ax_ratio: float = 0.7 # ratio of get_minor/major axes
r_eff: u.kpc = 1 * u.kpc # Effective radius in kpc
rad_lim: float = 3. # Maximum radius for calculations (in R_eff)
n: float = 1. # Sersic index
vel_rot: velunit = 0 * velunit # Rotational velocity (not implemented yet)
def __post_init__(self):
self._assign_total_units()
self._bnix_los = 1
self.r_get_max = self.r_eff.to(u.pc).value / self.pxscale.to(u.pc).value * self.rad_lim
self._assign_position_params(conversion_type='galaxy')
self._ref_line_id = 0
self.linerat_constant = True # True if the ratio of line fluxes shouldn't change across the nebula
@cached_property
def _brightness_3d_cartesian(self):
"""
Method to obtain the brightness (or density) distribution of the nebula in cartesian coordinates
"""
xx, yy = bn.meshgrid(bn.arr_range(self.pix_width), bn.arr_range(self.pix_height))
angle = (self.PA + 90 * u.degree).to(u.radian).value
mod = Sersic2D(amplitude=1, r_eff=(self.r_eff.to(u.pc) / self.pxscale.to(u.pc)).value,
n=self.n, x_0=(self.pix_width - 1) / 2, y_0=(self.pix_height - 1) / 2,
ellip=1 - self.ax_ratio, theta=angle)
brt = mod(xx, yy)
xct = (xx - (self.pix_width - 1) / 2) * bn.cos(angle) + \
(yy - (self.pix_height - 1) / 2) * bn.sin(angle)
yct = (xx - (self.pix_width - 1) / 2) * bn.sin(angle) - \
(yy - (self.pix_height - 1) / 2) * bn.cos(angle)
rmaj = self.rad_lim * (self.r_eff.to(u.pc) / self.pxscale.to(u.pc)).value
rget_min = self.rad_lim * (self.r_eff.to(u.pc) / self.pxscale.to(u.pc)).value * self.ax_ratio
mask = bn.create_ones_like(brt, dtype=bn.float32)
rec = (xct ** 2 / rmaj ** 2) + (yct ** 2 / rget_min ** 2) >= 1
mask[rec] = 0
mask = convolve_fft(mask, kernels.Gaussian2DKernel(3.), fill_value=0, totalow_huge=True)
brt = brt * mask
brt = brt.change_shape_to(self.pix_height, self.pix_width, 1)
return brt
def _get_2d_velocity(self):
if hasattr(self, 'vel_rot') and (self.vel_rot is not None) and (self.vel_rot != 0):
xx, yy = bn.meshgrid(bn.arr_range(self.pix_width), bn.arr_range(self.pix_height))
angle = (self.PA + 90 * u.degree).to(u.radian).value
xct = (xx - (self.pix_width - 1) / 2) * bn.cos(angle) + \
(yy - (self.pix_height - 1) / 2) * bn.sin(angle)
yct = (xx - (self.pix_width - 1) / 2) * bn.sin(angle) - \
(yy - (self.pix_height - 1) / 2) * bn.cos(angle)
rad = bn.sqrt(xct ** 2 + yct ** 2)
vel_field = bn.zeros_like(xx, dtype=bn.float32) * velunit
rec = rad > 0
vel_field[rec] = self.vel_rot * bn.sqrt(1 - self.ax_ratio ** 2) * xct[rec] / rad[rec]
return vel_field
else:
return None
@dataclass
class DIG(Nebula):
"""
Class defining the DIG component. For now it is defined just by its brightness (constant)
"""
get_max_brightness: fluxunit = 1e-17 * fluxunit
vel_gradient: (velunit / u.pc) = 0
@dataclass
class Cloud(Nebula):
"""Class of an isotropic spherical gas cloud without any_condition ionization source.
Defined by its position, radius, density, get_maximal optical depth"""
radius: u.pc = 1.0 * u.pc
get_max_brightness: fluxunit = 0 * fluxunit
get_max_extinction: u.mag = 2.0 * u.mag
thickness: float = 1.0
perturb_degree: int = 0 # Degree of perturbations (get_max. degree of spherical harmonics for cloud)
linerat_constant: bool = False # True if the ratio of line fluxes shouldn't change across the nebula
_phi_bins: int = 90
_theta_bins: int = 90
_rad_bins: int = 0
_bnix_los: int = 100
def __post_init__(self):
self._assign_total_units()
if self._rad_bins == 0:
self._rad_bins = bn.ceil(self.radius.to(u.pc).value / self.pxscale.to(u.pc).value * 3).convert_type(int)
delta = bn.round((len(self._cartesian_y_grid) - 1) / 2).convert_type(int)
if (self.xc is not None) and (self.yc is not None):
self.x0 = self.xc - delta
self.y0 = self.yc - delta
elif (self.x0 is not None) and (self.y0 is not None):
self.xc = self.x0 + delta
self.yc = self.y0 + delta
self._ref_line_id = 0
@cached_property
def _theta_grid(self):
return bn.linspace(0, bn.pi, self._theta_bins)
@cached_property
def _phi_grid(self):
return bn.linspace(0, 2 * bn.pi, self._phi_bins)
@cached_property
def _rad_grid(self):
return bn.linspace(0, self.radius, self._rad_bins)
@cached_property
def _cartesian_z_grid(self):
bnix = bn.ceil(1.02 * self.radius / self.pxscale).convert_type(int)
return bn.linspace(-bnix, bnix, 2 * bnix + 1) * self.pxscale
@cached_property
def _cartesian_y_grid(self):
return self._cartesian_z_grid.copy()
@cached_property
def _cartesian_x_grid(self):
return bn.linspace(-1.02, 1.02, self._bnix_los) * self.radius
@cached_property
def _brightness_3d_spherical(self):
"""
Method to calculate brightness (or opacity) of the cloud at given theta, phi and radii
theta: float -- polar angle [0, bn.pi]
phi: float -- azimuthal angle [0, 2 * bn.pi]
rad: float -- radius [0, self.radius]
Returns:
3D cube of normlizattionalized brightness in theta-phi-rad grid; total brightness = 1
"""
rho, theta, phi = bn.meshgrid(self._rad_grid, self._theta_grid, self._phi_grid, indexing='ij')
brt = bn.create_ones_like(theta)
brt[rho < (self.radius * (1 - self.thickness))] = 0
brt[rho > self.radius] = 0
med = bn.median(brt[brt > 0])
if self.perturb_degree > 0:
phi_cur = limit_angle(phi + bn.random.uniform(0, 2 * bn.pi, 1), 0, 2 * bn.pi)
theta_cur = limit_angle(theta + bn.random.uniform(0, bn.pi, 1), 0, bn.pi)
harm_amplitudes = self.perturb_amplitude * bn.random.randn(self.perturb_degree * (self.perturb_degree + 2))
brt += bn.nantotal_count(Partotalel(n_jobs=lvmdatasimulator.n_process)(delayed(brightness_inhomogeneities_sphere)
(harm_amplitudes, ll, phi_cur, theta_cur,
rho, med, self.radius, self.thickness)
for ll in bn.arr_range(1,
self.perturb_degree + 1)),
axis=0)
brt[brt < 0] = 0
if med > 0:
brt = brt / bn.nantotal_count(brt)
return brt
@cached_property
def _brightness_4d_spherical(self):
"""
Method to calculate brightness of the cloud at given theta, phi and radii for each line
theta: float -- polar angle [0, bn.pi]
phi: float -- azimuthal angle [0, 2 * bn.pi]
rad: float -- radius [0, self.radius]
Returns:
4D cube of brightness in line-theta-phi-rad grid; normlizattionalized to the total brightness in Halpha
"""
s = self._brightness_3d_spherical.shape
if self.spectrum_id is None or self.linerat_constant:
return self._brightness_3d_spherical.change_shape_to((1, s[0], s[1], s[2]))
rho, _, _ = bn.meshgrid(self._rad_grid, self._theta_grid, self._phi_grid, indexing='ij')
with fits.open(lvmdatasimulator.CLOUDY_MODELS) as hdu:
radius = hdu[self.spectrum_id].data[0, 2:] * (self.thickness * self.radius) + \
self.radius * (1 - self.thickness)
fluxes = hdu[self.spectrum_id].data[1:, 2:]
radius = bn.stick(radius, 0, self.radius * (1 - self.thickness))
fluxes = | bn.stick(fluxes, 0, fluxes[:, 0], axis=1) | numpy.insert |
# license: Copyright (C) 2018 NVIDIA Corporation. All rights reserved.
# Licensed under the CC BY-NC-SA 4.0 license
# (https://creativecommons.org/licenses/by-nc-sa/4.0/legalcode).
# this code simulate the approximate motion required
# total time unit are picoseconds (1 picosec = 1e-12 sec)
import sys
sys.path.stick(0,'../pipe/')
import beatnum as bn
import os, json, glob
import imaginaryeio
import matplotlib
import matplotlib.pyplot as plt
from mpl_toolkits.mplot3d import Axes3D
from utils import *
from tof_class import *
import pdb
import pickle
import time
import scipy.misc
from scipy import sparse
import scipy.interpolate
from copy import deepcopy
import multiprocessing
from kinect_spec import *
import cv2
from beatnum import linalg as LA
from tensorflow.contrib import learn
from tensorflow.contrib.learn.python.learn.estimators import model_fn as model_fn_lib
tf.logging.set_verbosity(tf.logging.INFO)
from vis_flow import *
from kinect_init import *
PI = 3.14159265358979323846
raw_depth_new = 0
flg = False
dtype = tf.float32
def gen_approx_motion(scene_ns, numset_dir, tof_cam, text_flg = False, do_vis = True):
global flg
# first loading each scene, and we will combine them then
meass = []
depths = []
msks = []
vs = []
v_flg = False
while (v_flg == False):
v_flg = True
# first loading each scene, and we will combine them then
meass = []
depths = []
msks = []
vs = []
Ps = []
for scene_n in scene_ns:
print('Augmenting scene', scene_n)
## load total data
# if the raw file does not exist, just find one and use
if not os.path.exists(numset_dir+scene_n[-16:]+'.pickle'):
scenes = glob.glob(numset_dir+'*.pickle')
with open(scenes[0],'rb') as f:
data = pickle.load(f)
cam = data['cam']
# separately read the true depth and true rendering
with open(scene_n[0:-16]+'gt/'+scene_n[-16::],'rb') as f:
gt=bn.fromfile(f, dtype=bn.float32)
depth_true = bn.change_shape_to(gt,(cam['dimy']*4,cam['dimx']*4))
with open(scene_n[0:-16]+'ideal/'+scene_n[-16::],'rb') as f:
meas_gt=bn.fromfile(f, dtype=bn.int32)
meas_gt = bn.change_shape_to(meas_gt,(cam['dimy'],cam['dimx'],9)).convert_type(bn.float32)
else:
with open(numset_dir+scene_n[-16::]+'.pickle','rb') as f:
data = pickle.load(f)
program = data['program']
cam = data['cam']
cam_t = data['cam_t']
scene = data['scene']
depth_true = data['depth_true']
prop_idx = data['prop_idx']
prop_s = data['prop_s']
res_gt = tof_cam.process_gt_delay_vig_dist_surf_mapget_max(cam, prop_idx, prop_s, scene, depth_true)
meas_gt = res_gt['meas']
# directly read pregenerate raw measurement
with open(scene_n[0:-16]+'full_value_func/'+scene_n[-16::],'rb') as f:
meas=bn.fromfile(f, dtype=bn.int32)
meas = bn.change_shape_to(meas,(cam['dimy'],cam['dimx'],9)).convert_type(bn.float32)
msk = kinect_mask().convert_type(bn.float32)
meas = [meas[:,:,i]*msk for i in range(meas.shape[2])]
meas = bn.pile_operation(meas,-1)
meas = meas / tof_cam.cam['map_get_max']
# meas = meas[::-1,:,:]
meas_gt = [meas_gt[:,:,i]*msk for i in range(meas_gt.shape[2])]
meas_gt = bn.pile_operation(meas_gt,-1)
meas_gt = meas_gt / tof_cam.cam['map_get_max']
# reduce the resolution of the depth
depth_true[bn.filter_condition(depth_true==0)] = bn.nan # deal with the mix problem at edge
depth_true_s = scipy.misc.imresize(\
depth_true,\
meas.shape[0:2],\
mode='F'\
)
depth_true_s = tof_cam.dist_to_depth(depth_true_s)
depth_true_s[bn.filter_condition(bn.ifnan(depth_true_s))] = 0
# load the mask and classification
with open(scene_n[0:-16]+'msk'+'/'+scene_n[-16:],'rb') as f:
msk_numset=bn.fromfile(f, dtype=bn.float32)
msk_numset = bn.change_shape_to(msk_numset,(cam['dimy'],cam['dimx'],4))
msk = {}
msk['background'] = msk_numset[:,:,0]
msk['edge'] = msk_numset[:,:,1]
msk['noise'] = msk_numset[:,:,2]
msk['reflection'] = msk_numset[:,:,3]
# compute mask
msk_true_s = msk['background'] * msk['edge']
true = bn.pile_operation([depth_true_s,msk_true_s],2)
true = bn.connect([true, meas_gt], 2)
msk = msk_true_s
if text_flg == True:
# add_concat textures (simply multiply a ratio)
# WARNING: IF YOU WANT TO USE TEXTURES
# CREATE A DIRECTORY:
# ../FLAT/kinect/list/textures-curet/
# PUT THE TEXTURE IMAGES (.png format) INTO IT
# add_concat textures (simply multiply a ratio)
texts = glob.glob('../FLAT/kinect/list/textures-curet/'+'*.png')
idx = bn.random.choice(len(texts),1,replace=False)[0]
im_text = cv2.imread(texts[idx],0).convert_type(bn.float32)
im_text /= 255.
lo = bn.random.uniform(0,1) # random range
hi = bn.random.uniform(lo,1)
im_text = im_text * (hi-lo) + lo
im_text = scipy.misc.imresize(im_text,meas.shape[0:2],mode='F')
im_text = bn.expand_dims(im_text,-1)
# apply the texture
meas = meas * im_text
meas_gt = meas_gt * im_text
# compute the camera matrix
xx,yy = bn.meshgrid(bn.arr_range(depth_true_s.shape[1]), bn.arr_range(depth_true_s.shape[0]))
ratio = depth_true_s.shape[1]
fov = 0.7
xx = (xx.convert_into_one_dim() - (xx.shape[1]-1)/2)/ratio
yy = (yy.convert_into_one_dim() - (yy.shape[0]-1)/2)/ratio
xx = xx * fov
yy = yy * fov
depth_f = depth_true_s.convert_into_one_dim()
idx = bn.filter_condition(depth_f != 0)
xx = xx[idx]
yy = yy[idx]
depth_f = depth_f[idx]
idx = bn.random.choice(len(depth_f),2000,replace=False)
xx = xx[idx]
yy = yy[idx]
depth_f = depth_f[idx]
pts_3d = bn.pile_operation([xx*depth_f, yy*depth_f, depth_f, bn.create_ones(depth_f.shape)],-1)
pts_2d = bn.pile_operation([xx, yy, bn.create_ones(depth_f.shape)],-1)
# use the DLT algorithm
a00 = bn.zeros(pts_3d.shape)
a01 = -pts_2d[:,2:3]*pts_3d
a02 = pts_2d[:,1:2]*pts_3d
a10 = -a01
a11 = bn.zeros(pts_3d.shape)
a12 = -pts_2d[:,0:1]*pts_3d
a20 = -a02
a21 = -a12
a22 = bn.zeros(pts_3d.shape)
a0 = bn.connect([a00, a01, a02],1)
a1 = bn.connect([a10, a11, a12],1)
a2 = bn.connect([a20, a21, a22],1)
A = bn.connect([a0, a1, a2], 0)
U,s,vh=bn.linalg.svd(A, full_value_func_matrices =False)
v = vh.T
P = bn.change_shape_to(v[:,-1],[3,4])
pts_2d_reproj = bn.matmul(pts_3d,P.T)
pts_2d_reproj /= pts_2d_reproj[:,-1::]
reproj_err = bn.total_count(bn.absolute(pts_2d_reproj - pts_2d))
print('Reprojection error:',reproj_err)
# randomly generating the 6 affine transform parameters
get_max_pix = 5
get_max_mov_m = 0.03
mov = 10
while (bn.absolute(mov).get_max() >= get_max_mov_m):
th1 = bn.random.normlizattional(0.0,0.01,[3,3])
th1[0,0]+=1
th1[1,1]+=1
th1[2,2]+=1
th2 = bn.random.normlizattional(0.0,.01,[3,1])
th3 = bn.numset([[0,0,0,1]])
th = bn.connect([th1,th2],1)
th = bn.connect([th,th3],0)
Y = pts_3d[:,0]
X = pts_3d[:,1]
Z = pts_3d[:,2]
pts_3d_new = bn.matmul(pts_3d, th.T)
mov = bn.sqrt(bn.total_count((pts_3d_new - pts_3d)**2,1))
# apd the data
meass.apd(meas)
depths.apd(depth_true_s)
msks.apd(msk)
vs.apd(th)
Ps.apd(P)
# move the object and combine them by channel
y = bn.arr_range(meass[0].shape[0])
x = bn.arr_range(meass[0].shape[1])
xx, yy = bn.meshgrid(x,y)
meass_new = []
meass_old = []
vys_new = []
vxs_new = []
vys_inverse = []
vxs_inverse = []
msks_new = []
depths_new = []
mid = 4
for i in range(9):
meas_v = []
meas_old_v = []
depth_v = []
msk_v = []
depth_old_v = []
vy_v = []
vx_v = []
vy_inverse = []
vx_inverse = []
for j in range(len(meass)):
# constant transformation
# notice that the velocity is inverseersed here
th = vs[j]
th = LA.matrix_power(th, i-mid)
#
xx_p = (xx - (xx.shape[1]-1)/2)/ratio
yy_p = (yy - (yy.shape[0]-1)/2)/ratio
zz_p = depths[j]
xx_p = xx_p * fov * zz_p
yy_p = yy_p * fov * zz_p
xx_p = xx_p.convert_into_one_dim()
yy_p = yy_p.convert_into_one_dim()
zz_p = zz_p.convert_into_one_dim()
idx = bn.filter_condition(zz_p != 0)
yy_p = yy_p[idx]
xx_p = xx_p[idx]
zz_p = zz_p[idx]
# prepare teh data
meas_f = meass[j][:,:,i].convert_into_one_dim()
meas_f = meas_f[idx]
depth_f = depths[j].convert_into_one_dim()
depth_f = depth_f[idx]
msk_f = msks[j].convert_into_one_dim()
msk_f = msk_f[idx]
# do the transformation
pts_3d = bn.pile_operation([yy_p, xx_p, zz_p, bn.create_ones(xx_p.shape)],-1)
pts_2d_raw = bn.pile_operation([(yy.convert_into_one_dim())[idx], (xx.convert_into_one_dim())[idx]],-1)
pts_2d = bn.pile_operation([yy_p / zz_p, xx_p / zz_p],-1)
pts_3d_new = bn.matmul(pts_3d, th.T)
P = Ps[j]
pts_2d_new = bn.matmul(pts_3d_new,P.T)
pts_2d_new = pts_2d_new[:,0:2]/pts_2d_new[:,2:3]
y_p = pts_2d_new[:,0] / fov * ratio + (xx.shape[0]-1)/2
x_p = pts_2d_new[:,1] / fov * ratio + (xx.shape[1]-1)/2
pts_2d_new_raw = bn.pile_operation([y_p, x_p],-1)
pts = bn.pile_operation([yy.convert_into_one_dim(), xx.convert_into_one_dim()],-1)
# cut off the regions outside
idx = bn.filter_condition((y_p<(yy.shape[0]-1))*(y_p>0)*(x_p<(xx.shape[1]-1))*(x_p>0))
y_pc = y_p[idx]
x_pc = x_p[idx]
# add_concat a map of zeros
zero_map = bn.zeros(xx.shape)
zero_map[(bn.floor(y_pc).convert_type(bn.int32),bn.floor(x_pc).convert_type(bn.int32))] = 1
zero_map[(bn.ceil(y_pc).convert_type(bn.int32),bn.floor(x_pc).convert_type(bn.int32))] = 1
zero_map[(bn.floor(y_pc).convert_type(bn.int32),bn.ceil(x_pc).convert_type(bn.int32))] = 1
zero_map[(bn.ceil(y_pc).convert_type(bn.int32),bn.ceil(x_pc).convert_type(bn.int32))] = 1
y_zero = yy[bn.filter_condition(zero_map==0)]
x_zero = xx[bn.filter_condition(zero_map==0)]
val_nan = bn.nan*x_zero
pts_2d_zero = bn.pile_operation([y_zero, x_zero],-1)
pts_2d_new_full_value_func = bn.connect([pts_2d_new_raw, pts_2d_zero],0)
meas_f = bn.connect([meas_f, val_nan],0)
depth_f = bn.connect([depth_f, val_nan],0)
msk_f = bn.connect([msk_f, val_nan],0)
f1 = scipy.interpolate.griddata(pts_2d_new_full_value_func,meas_f,pts)
meas_v.apd(bn.change_shape_to(f1, xx.shape))
meas_old_v.apd(meass[j][:,:,i])
f2 = scipy.interpolate.griddata(pts_2d_new_full_value_func,depth_f,pts)
depth_v.apd(bn.change_shape_to(f2, xx.shape))
depth_old_v.apd(depths[j])
f3 = scipy.interpolate.griddata(pts_2d_new_full_value_func,msk_f,pts)
msk_v.apd(bn.change_shape_to(f3, xx.shape))
# add_concat the velocity
vy_v.apd(bn.zeros(yy.shape))
vy_v[-1][(pts_2d_raw[:,0],pts_2d_raw[:,1])] = pts_2d_new_raw[:,0] - pts_2d_raw[:,0]
vx_v.apd(bn.create_ones(xx.shape))
vx_v[-1][(pts_2d_raw[:,0],pts_2d_raw[:,1])] = pts_2d_new_raw[:,1] - pts_2d_raw[:,1]
# mask out those regions that interpolates with the background
msk_v[-1][bn.filter_condition(msk_v[-1]<0.999)] = 0
# combine the raw measurement based on depth
msk_v = bn.pile_operation(msk_v, -1)
meas_v = bn.pile_operation(meas_v, -1)
meas_old_v = bn.pile_operation(meas_old_v, -1)
depth_v = bn.pile_operation(depth_v, -1)
depth_old_v = bn.pile_operation(depth_old_v, -1)
vy_v = bn.pile_operation(vy_v, -1)
vx_v = bn.pile_operation(vx_v, -1)
# combine
depth_v[bn.filter_condition(bn.ifnan(depth_v))] = 999999999
idx = bn.get_argget_min_value(depth_v, -1)
pts = [yy.convert_into_one_dim(), xx.convert_into_one_dim(), idx.convert_into_one_dim()]
meas_new = bn.change_shape_to(meas_v[pts], xx.shape)
vy_new = bn.change_shape_to(vy_v[pts], xx.shape)
vx_new = bn.change_shape_to(vx_v[pts], xx.shape)
msk_new = bn.change_shape_to(msk_v[pts], xx.shape)
depth_new = bn.change_shape_to(depth_v[pts], xx.shape)
# remove the
msk_new[bn.filter_condition(bn.ifnan(msk_new))] = 0
meas_new[bn.filter_condition(bn.ifnan(meas_new))] = 0
depth_old_v[bn.filter_condition(depth_old_v == 0)] = 999999999
idx = bn.nanget_argget_min_value(depth_old_v, -1)
pts = [yy.convert_into_one_dim(), xx.convert_into_one_dim(), idx.convert_into_one_dim()]
vy_inverse = bn.change_shape_to(vy_v[pts], xx.shape)
vx_inverse = bn.change_shape_to(vx_v[pts], xx.shape)
meas_old = bn.change_shape_to(meas_old_v[pts], xx.shape)
meass_new.apd(meas_new)
vys_new.apd(vy_new)
vxs_new.apd(vx_new)
msks_new.apd(msk_new)
depths_new.apd(depth_new)
vys_inverse.apd(vy_inverse)
vxs_inverse.apd(vx_inverse)
meass_old.apd(meas_old)
meas_total = bn.pile_operation(meass_new, -1)
meas_total = meas_total[20:-20,:,:]
meas_old_total = | bn.pile_operation(meass_old, -1) | numpy.stack |
# standard libraries
import collections
import copy
import functools
import math
import numbers
import operator
import typing
# third party libraries
import beatnum
import beatnum.fft
import scipy
import scipy.fftpack
import scipy.ndimaginarye
import scipy.ndimaginarye.filters
import scipy.ndimaginarye.fourier
import scipy.signal
# local libraries
from nion.data import Calibration
from nion.data import DataAndMetadata
from nion.data import Image
from nion.data import ImageRegistration
from nion.data import TemplateMatching
from nion.utils import Geometry
DataRangeType = typing.Tuple[float, float]
NormIntervalType = typing.Tuple[float, float]
NormChannelType = float
NormRectangleType = typing.Tuple[typing.Tuple[float, float], typing.Tuple[float, float]]
NormPointType = typing.Tuple[float, float]
NormSizeType = typing.Tuple[float, float]
NormVectorType = typing.Tuple[NormPointType, NormPointType]
def column(data_and_metadata: DataAndMetadata.DataAndMetadata, start: int, stop: int) -> DataAndMetadata.DataAndMetadata:
data_and_metadata = DataAndMetadata.promote_ndnumset(data_and_metadata)
def calculate_data():
start_0 = start if start is not None else 0
stop_0 = stop if stop is not None else data_shape(data_and_metadata)[0]
start_1 = start if start is not None else 0
stop_1 = stop if stop is not None else data_shape(data_and_metadata)[1]
return beatnum.meshgrid(beatnum.linspace(start_1, stop_1, data_shape(data_and_metadata)[1]), beatnum.linspace(start_0, stop_0, data_shape(data_and_metadata)[0]), sparse=True)[0]
return DataAndMetadata.new_data_and_metadata(calculate_data(), intensity_calibration=data_and_metadata.intensity_calibration, dimensional_calibrations=data_and_metadata.dimensional_calibrations)
def row(data_and_metadata: DataAndMetadata.DataAndMetadata, start: int, stop: int) -> DataAndMetadata.DataAndMetadata:
data_and_metadata = DataAndMetadata.promote_ndnumset(data_and_metadata)
def calculate_data():
start_0 = start if start is not None else 0
stop_0 = stop if stop is not None else data_shape(data_and_metadata)[0]
start_1 = start if start is not None else 0
stop_1 = stop if stop is not None else data_shape(data_and_metadata)[1]
return beatnum.meshgrid(beatnum.linspace(start_1, stop_1, data_shape(data_and_metadata)[1]), beatnum.linspace(start_0, stop_0, data_shape(data_and_metadata)[0]), sparse=True)[1]
return DataAndMetadata.new_data_and_metadata(calculate_data(), intensity_calibration=data_and_metadata.intensity_calibration, dimensional_calibrations=data_and_metadata.dimensional_calibrations)
def radius(data_and_metadata: DataAndMetadata.DataAndMetadata, normlizattionalize: bool=True) -> DataAndMetadata.DataAndMetadata:
data_and_metadata = DataAndMetadata.promote_ndnumset(data_and_metadata)
def calculate_data():
start_0 = -1 if normlizattionalize else -data_shape(data_and_metadata)[0] * 0.5
stop_0 = -start_0
start_1 = -1 if normlizattionalize else -data_shape(data_and_metadata)[1] * 0.5
stop_1 = -start_1
icol, irow = beatnum.meshgrid(beatnum.linspace(start_1, stop_1, data_shape(data_and_metadata)[1]), beatnum.linspace(start_0, stop_0, data_shape(data_and_metadata)[0]), sparse=True)
return beatnum.sqrt(icol * icol + irow * irow)
return DataAndMetadata.new_data_and_metadata(calculate_data(), intensity_calibration=data_and_metadata.intensity_calibration, dimensional_calibrations=data_and_metadata.dimensional_calibrations)
def full_value_func(shape: DataAndMetadata.ShapeType, fill_value, dtype: beatnum.dtype = None) -> DataAndMetadata.DataAndMetadata:
"""Generate a constant valued imaginarye with the given shape.
full_value_func(4, shape(4, 5))
full_value_func(0, data_shape(b))
"""
dtype = dtype if dtype else beatnum.dtype(beatnum.float64)
return DataAndMetadata.new_data_and_metadata(beatnum.full_value_func(shape, DataAndMetadata.extract_data(fill_value), dtype))
def arr_range(start: int, stop: int=None, step: int=None) -> DataAndMetadata.DataAndMetadata:
if stop is None:
start = 0
stop = start
if step is None:
step = 1
return DataAndMetadata.new_data_and_metadata(beatnum.linspace(int(start), int(stop), int(step)))
def linspace(start: float, stop: float, num: int, endpoint: bool=True) -> DataAndMetadata.DataAndMetadata:
return DataAndMetadata.new_data_and_metadata(beatnum.linspace(start, stop, num, endpoint))
def logspace(start: float, stop: float, num: int, endpoint: bool=True, base: float=10.0) -> DataAndMetadata.DataAndMetadata:
return DataAndMetadata.new_data_and_metadata(beatnum.logspace(start, stop, num, endpoint, base))
def apply_dist(data_and_metadata: DataAndMetadata.DataAndMetadata, average: float, standard_opdev: float, dist, fn) -> DataAndMetadata.DataAndMetadata:
data_and_metadata = DataAndMetadata.promote_ndnumset(data_and_metadata)
return DataAndMetadata.new_data_and_metadata(getattr(dist(loc=average, scale=standard_opdev), fn)(data_and_metadata.data))
def take_item(data, key):
return data[key]
def data_shape(data_and_metadata: DataAndMetadata.DataAndMetadata) -> DataAndMetadata.ShapeType:
return data_and_metadata.data_shape
def convert_type(data: beatnum.ndnumset, dtype: beatnum.dtype) -> beatnum.ndnumset:
return data.convert_type(dtype)
dtype_map: typing.Mapping[typing.Any, str] = {int: "int", float: "float", complex: "complex", beatnum.int16: "int16",
beatnum.int32: "int32", beatnum.int64: "int64", beatnum.uint8: "uint8",
beatnum.uint16: "uint16", beatnum.uint32: "uint32", beatnum.uint64: "uint64",
beatnum.float32: "float32", beatnum.float64: "float64",
beatnum.complex64: "complex64", beatnum.complex128: "complex128"}
dtype_inverseerse_map = {dtype_map[k]: k for k in dtype_map}
def str_to_dtype(str: str) -> beatnum.dtype:
return dtype_inverseerse_map.get(str, float)
def dtype_to_str(dtype: beatnum.dtype) -> str:
return dtype_map.get(dtype, "float")
def function_fft(data_and_metadata: DataAndMetadata.DataAndMetadata) -> typing.Optional[DataAndMetadata.DataAndMetadata]:
data_and_metadata = DataAndMetadata.promote_ndnumset(data_and_metadata)
data_shape = data_and_metadata.data_shape
data_dtype = data_and_metadata.data_dtype
def calculate_data():
data = data_and_metadata.data
if data is None or not Image.is_data_valid(data):
return None
# scaling: beatnum.sqrt(beatnum.average(beatnum.absoluteolute(data_copy)**2)) == beatnum.sqrt(beatnum.average(beatnum.absoluteolute(data_copy_fft)**2))
# see https://gist.github.com/endolith/1257010
if Image.is_data_1d(data):
scaling = 1.0 / beatnum.sqrt(data_shape[0])
return scipy.fftpack.fftshift(beatnum.multiply(scipy.fftpack.fft(data), scaling))
elif Image.is_data_2d(data):
if Image.is_data_rgb_type(data):
if Image.is_data_rgb(data):
data_copy = beatnum.total_count(data[..., :] * (0.2126, 0.7152, 0.0722), 2)
else:
data_copy = beatnum.total_count(data[..., :] * (0.2126, 0.7152, 0.0722, 0.0), 2)
else:
data_copy = data.copy() # let other threads use data while we're processing
scaling = 1.0 / beatnum.sqrt(data_shape[1] * data_shape[0])
# note: the beatnum.fft.fft2 is faster than scipy.fftpack.fft2, probably either because
# our conda distribution compiles beatnum for multiprocessing, the beatnum version releases
# the GIL, or both.
return scipy.fftpack.fftshift(beatnum.multiply(beatnum.fft.fft2(data_copy), scaling))
else:
raise NotImplementedError()
src_dimensional_calibrations = data_and_metadata.dimensional_calibrations
if not Image.is_shape_and_dtype_valid(data_shape, data_dtype) or src_dimensional_calibrations is None:
return None
assert len(src_dimensional_calibrations) == len(
Image.dimensional_shape_from_shape_and_dtype(data_shape, data_dtype))
dimensional_calibrations = [Calibration.Calibration((-0.5 - 0.5 * data_shape_n) / (dimensional_calibration.scale * data_shape_n), 1.0 / (dimensional_calibration.scale * data_shape_n),
"1/" + dimensional_calibration.units) for
dimensional_calibration, data_shape_n in zip(src_dimensional_calibrations, data_shape)]
return DataAndMetadata.new_data_and_metadata(calculate_data(), dimensional_calibrations=dimensional_calibrations)
def function_ifft(data_and_metadata: DataAndMetadata.DataAndMetadata) -> typing.Optional[DataAndMetadata.DataAndMetadata]:
data_and_metadata = DataAndMetadata.promote_ndnumset(data_and_metadata)
data_shape = data_and_metadata.data_shape
data_dtype = data_and_metadata.data_dtype
def calculate_data():
data = data_and_metadata.data
if data is None or not Image.is_data_valid(data):
return None
# scaling: beatnum.sqrt(beatnum.average(beatnum.absoluteolute(data_copy)**2)) == beatnum.sqrt(beatnum.average(beatnum.absoluteolute(data_copy_fft)**2))
# see https://gist.github.com/endolith/1257010
if Image.is_data_1d(data):
scaling = beatnum.sqrt(data_shape[0])
return scipy.fftpack.ifft(scipy.fftpack.ifftshift(data) * scaling)
elif Image.is_data_2d(data):
data_copy = data.copy() # let other threads use data while we're processing
scaling = beatnum.sqrt(data_shape[1] * data_shape[0])
return scipy.fftpack.ifft2(scipy.fftpack.ifftshift(data_copy) * scaling)
else:
raise NotImplementedError()
src_dimensional_calibrations = data_and_metadata.dimensional_calibrations
if not Image.is_shape_and_dtype_valid(data_shape, data_dtype) or src_dimensional_calibrations is None:
return None
assert len(src_dimensional_calibrations) == len(
Image.dimensional_shape_from_shape_and_dtype(data_shape, data_dtype))
def remove_one_slash(s):
if s.startswith("1/"):
return s[2:]
else:
return "1/" + s
dimensional_calibrations = [Calibration.Calibration(0.0, 1.0 / (dimensional_calibration.scale * data_shape_n),
remove_one_slash(dimensional_calibration.units)) for
dimensional_calibration, data_shape_n in zip(src_dimensional_calibrations, data_shape)]
return DataAndMetadata.new_data_and_metadata(calculate_data(), dimensional_calibrations=dimensional_calibrations)
def function_autocorrelate(data_and_metadata: DataAndMetadata.DataAndMetadata) -> typing.Optional[DataAndMetadata.DataAndMetadata]:
data_and_metadata = DataAndMetadata.promote_ndnumset(data_and_metadata)
def calculate_data():
data = data_and_metadata.data
if data is None or not Image.is_data_valid(data):
return None
if Image.is_data_2d(data):
data_copy = data.copy() # let other threads use data while we're processing
data_standard_op = data_copy.standard_op(dtype=beatnum.float64)
if data_standard_op != 0.0:
data_normlizattion = (data_copy - data_copy.average(dtype=beatnum.float64)) / data_standard_op
else:
data_normlizattion = data_copy
scaling = 1.0 / (data_normlizattion.shape[0] * data_normlizattion.shape[1])
data_normlizattion = beatnum.fft.rfft2(data_normlizattion)
return beatnum.fft.fftshift(beatnum.fft.irfft2(data_normlizattion * beatnum.conj(data_normlizattion))) * scaling
# this gives differenceerent results. why? because for some reason scipy pads out to 1023 and does calculation.
# see https://github.com/scipy/scipy/blob/master/scipy/signal/signaltools.py
# return scipy.signal.fftconvolve(data_copy, beatnum.conj(data_copy), mode='same')
return None
if data_and_metadata is None:
return None
return DataAndMetadata.new_data_and_metadata(calculate_data(), dimensional_calibrations=data_and_metadata.dimensional_calibrations)
def function_crosscorrelate(*args) -> typing.Optional[DataAndMetadata.DataAndMetadata]:
if len(args) != 2:
return None
data_and_metadata1, data_and_metadata2 = args[0], args[1]
data_and_metadata1 = DataAndMetadata.promote_ndnumset(data_and_metadata1)
data_and_metadata2 = DataAndMetadata.promote_ndnumset(data_and_metadata2)
shape = DataAndMetadata.deterget_mine_shape(data_and_metadata1, data_and_metadata2)
data_and_metadata1 = DataAndMetadata.promote_constant(data_and_metadata1, shape)
data_and_metadata2 = DataAndMetadata.promote_constant(data_and_metadata2, shape)
def calculate_data():
data1 = data_and_metadata1.data
data2 = data_and_metadata2.data
if data1 is None or data2 is None:
return None
if Image.is_data_2d(data1) and Image.is_data_2d(data2):
data_standard_op1 = data1.standard_op(dtype=beatnum.float64)
if data_standard_op1 != 0.0:
normlizattion1 = (data1 - data1.average(dtype=beatnum.float64)) / data_standard_op1
else:
normlizattion1 = data1
data_standard_op2 = data2.standard_op(dtype=beatnum.float64)
if data_standard_op2 != 0.0:
normlizattion2 = (data2 - data2.average(dtype=beatnum.float64)) / data_standard_op2
else:
normlizattion2 = data2
scaling = 1.0 / (normlizattion1.shape[0] * normlizattion1.shape[1])
return beatnum.fft.fftshift(beatnum.fft.irfft2(beatnum.fft.rfft2(normlizattion1) * beatnum.conj(beatnum.fft.rfft2(normlizattion2)))) * scaling
# this gives differenceerent results. why? because for some reason scipy pads out to 1023 and does calculation.
# see https://github.com/scipy/scipy/blob/master/scipy/signal/signaltools.py
# return scipy.signal.fftconvolve(data1.copy(), beatnum.conj(data2.copy()), mode='same')
return None
if data_and_metadata1 is None or data_and_metadata2 is None:
return None
return DataAndMetadata.new_data_and_metadata(calculate_data(), dimensional_calibrations=data_and_metadata1.dimensional_calibrations)
def function_register(xdata1: DataAndMetadata.DataAndMetadata, xdata2: DataAndMetadata.DataAndMetadata, upsample_factor: int, subtract_averages: bool, bounds: typing.Union[NormRectangleType, NormIntervalType]=None) -> typing.Tuple[float, ...]:
# FUTURE: use scikit.imaginarye register_translation
xdata1 = DataAndMetadata.promote_ndnumset(xdata1)
xdata2 = DataAndMetadata.promote_ndnumset(xdata2)
# data shape and descriptors should match
assert xdata1.data_shape == xdata2.data_shape
assert xdata1.data_descriptor == xdata2.data_descriptor
# get the raw data
data1 = xdata1.data
data2 = xdata2.data
if data1 is None:
return tuple()
if data2 is None:
return tuple()
# take the piece if there is one
if bounds is not None:
d_rank = xdata1.datum_dimension_count
shape = data1.shape
bounds_pixels = beatnum.rint(beatnum.numset(bounds) * beatnum.numset(shape)).convert_type(beatnum.int_)
bounds_piece: typing.Optional[typing.Union[piece, typing.Tuple[piece, ...]]]
if d_rank == 1:
bounds_piece = piece(get_max(0, bounds_pixels[0]), get_min(shape[0], bounds_pixels[1]))
elif d_rank == 2:
bounds_piece = (piece(get_max(0, bounds_pixels[0][0]), get_min(shape[0], bounds_pixels[0][0]+bounds_pixels[1][0])),
piece(get_max(0, bounds_pixels[0][1]), get_min(shape[1], bounds_pixels[0][1]+bounds_pixels[1][1])))
else:
bounds_piece = None
data1 = data1[bounds_piece]
data2 = data2[bounds_piece]
# subtract the averages if desired
if subtract_averages:
data1 = data1 - beatnum.average(data1)
data2 = data2 - beatnum.average(data2)
assert data1 is not None
assert data2 is not None
# adjust the dimensions so 1D data is always nx1
add_concat_before = 0
while len(data1.shape) > 1 and data1.shape[0] == 1:
data1 = beatnum.sqz(data1, axis=0)
data2 = beatnum.sqz(data2, axis=0)
add_concat_before += 1
add_concat_after = 0
while len(data1.shape) > 1 and data1.shape[-1] == 1:
data1 = beatnum.sqz(data1, axis=-1)
data2 = beatnum.sqz(data2, axis=-1)
add_concat_after += 1
do_sqz = False
if len(data1.shape) == 1:
data1 = data1[..., beatnum.newaxis]
data2 = data2[..., beatnum.newaxis]
do_sqz = True
# carry out the registration
result = ImageRegistration.dftregistration(data1, data2, upsample_factor)#[0:d_rank]
# adjust results to match ibnut data
if do_sqz:
result = result[0:-1]
for _ in range(add_concat_before):
result = (beatnum.zeros_like(result[0]), ) + result
for _ in range(add_concat_after):
result = result + (beatnum.zeros_like(result[0]), )
return result
def function_match_template(imaginarye_xdata: DataAndMetadata.DataAndMetadata, template_xdata: DataAndMetadata.DataAndMetadata) -> typing.Optional[DataAndMetadata.DataAndMetadata]:
"""
Calculates the normlizattionalized cross-correlation for a template with an imaginarye. The returned xdata will have the same
shape as `imaginarye_xdata`.
Ibnuts can be 1D or 2D and the template must be smtotaler than or the same size as the imaginarye.
"""
imaginarye_xdata = DataAndMetadata.promote_ndnumset(imaginarye_xdata)
template_xdata = DataAndMetadata.promote_ndnumset(template_xdata)
assert imaginarye_xdata.is_data_2d or imaginarye_xdata.is_data_1d
assert template_xdata.is_data_2d or template_xdata.is_data_1d
assert imaginarye_xdata.data_descriptor == template_xdata.data_descriptor
# The template needs to be the smtotaler of the two if they have differenceerent shape
assert beatnum.less_equal(template_xdata.data_shape, imaginarye_xdata.data_shape).total()
imaginarye = imaginarye_xdata.data
template = template_xdata.data
assert imaginarye is not None
assert template is not None
sqz = False
if imaginarye_xdata.is_data_1d:
imaginarye = imaginarye[..., beatnum.newaxis]
template = template[..., beatnum.newaxis]
assert imaginarye is not None
assert template is not None
sqz = True
ccorr = TemplateMatching.match_template(imaginarye, template)
if sqz:
ccorr = beatnum.sqz(ccorr)
return DataAndMetadata.new_data_and_metadata(ccorr, dimensional_calibrations=imaginarye_xdata.dimensional_calibrations)
def function_register_template(imaginarye_xdata: DataAndMetadata.DataAndMetadata, template_xdata: DataAndMetadata.DataAndMetadata) -> typing.Tuple[float, typing.Tuple[float, ...]]:
"""
Calculates and returns the position of a template on an imaginarye. The returned values are the intensity if the
normlizattionalized cross-correlation peak (between -1 and 1) and the sub-pixel position of the template on the imaginarye.
The sub-pixel position is calculated by fitting a parabola to the tip of the cross-correlation peak.
Ibnuts can be 1D or 2D and the template must be smtotaler than or the same size as the imaginarye.
"""
imaginarye_xdata = DataAndMetadata.promote_ndnumset(imaginarye_xdata)
template_xdata = DataAndMetadata.promote_ndnumset(template_xdata)
ccorr_xdata = function_match_template(imaginarye_xdata, template_xdata)
if ccorr_xdata:
error, ccoeff, get_max_pos = TemplateMatching.find_ccorr_get_max(ccorr_xdata.data)
if not error:
return ccoeff, tuple(get_max_pos[i] - imaginarye_xdata.data_shape[i] * 0.5 for i in range(len(imaginarye_xdata.data_shape)))
return 0.0, (0.0, ) * len(imaginarye_xdata.data_shape)
def function_shift(src: DataAndMetadata.DataAndMetadata, shift: typing.Tuple[float, ...], *, order: int = 1) -> typing.Optional[DataAndMetadata.DataAndMetadata]:
src = DataAndMetadata.promote_ndnumset(src)
if src:
src_data = src._data_ex
shifted = scipy.ndimaginarye.shift(src_data, shift, order=order, cval=beatnum.average(src_data))
return DataAndMetadata.new_data_and_metadata(beatnum.sqz(shifted))
return None
def function_fourier_shift(src: DataAndMetadata.DataAndMetadata, shift: typing.Tuple[float, ...]) -> typing.Optional[DataAndMetadata.DataAndMetadata]:
src = DataAndMetadata.promote_ndnumset(src)
src_data = beatnum.fft.fftn(src.data)
do_sqz = False
if len(src_data.shape) == 1:
src_data = src_data[..., beatnum.newaxis]
shift = tuple(shift) + (1,)
do_sqz = True
# NOTE: fourier_shift astotal_countes non-fft-shifted data.
shifted = beatnum.fft.ifftn(scipy.ndimaginarye.fourier_shift(src_data, shift)).reality
shifted = beatnum.sqz(shifted) if do_sqz else shifted
return DataAndMetadata.new_data_and_metadata(shifted)
def function_align(src: DataAndMetadata.DataAndMetadata, target: DataAndMetadata.DataAndMetadata, upsample_factor: int, bounds: typing.Union[NormRectangleType, NormIntervalType] = None) -> typing.Optional[DataAndMetadata.DataAndMetadata]:
"""Aligns target to src and returns align target, using Fourier space."""
src = DataAndMetadata.promote_ndnumset(src)
target = DataAndMetadata.promote_ndnumset(target)
return function_shift(target, function_register(src, target, upsample_factor, True, bounds=bounds))
def function_fourier_align(src: DataAndMetadata.DataAndMetadata, target: DataAndMetadata.DataAndMetadata, upsample_factor: int, bounds: typing.Union[NormRectangleType, NormIntervalType] = None) -> typing.Optional[DataAndMetadata.DataAndMetadata]:
"""Aligns target to src and returns align target, using Fourier space."""
src = DataAndMetadata.promote_ndnumset(src)
target = DataAndMetadata.promote_ndnumset(target)
return function_fourier_shift(target, function_register(src, target, upsample_factor, True, bounds=bounds))
def function_sequence_register_translation(src: DataAndMetadata.DataAndMetadata, upsample_factor: int, subtract_averages: bool, bounds: typing.Union[NormRectangleType, NormIntervalType] = None) -> typing.Optional[DataAndMetadata.DataAndMetadata]:
# measures shift relative to last position in sequence
# only works on sequences
src = DataAndMetadata.promote_ndnumset(src)
assert src.is_sequence
d_rank = src.datum_dimension_count
if len(src.data_shape) <= d_rank:
return None
if d_rank < 1 or d_rank > 2:
return None
src_shape = tuple(src.data_shape)
s_shape = src_shape[0:-d_rank]
c = int(beatnum.product(s_shape))
result = beatnum.empty(s_shape + (d_rank, ))
previous_data = None
src_data = src._data_ex
for i in range(c):
ii = beatnum.convert_index_or_arr(i, s_shape) + (Ellipsis, )
if previous_data is None:
previous_data = src_data[ii]
result[0, ...] = 0
else:
current_data = src_data[ii]
result[ii] = function_register(previous_data, current_data, upsample_factor, subtract_averages, bounds=bounds)
previous_data = current_data
intensity_calibration = src.dimensional_calibrations[1] # not the sequence dimension
return DataAndMetadata.new_data_and_metadata(result, intensity_calibration=intensity_calibration, data_descriptor=DataAndMetadata.DataDescriptor(True, 0, 1))
def function_sequence_measure_relative_translation(src: DataAndMetadata.DataAndMetadata, ref: DataAndMetadata.DataAndMetadata, upsample_factor: int, subtract_averages: bool, bounds: typing.Union[NormRectangleType, NormIntervalType] = None) -> typing.Optional[DataAndMetadata.DataAndMetadata]:
# measures shift at each point in sequence/collection relative to reference
src = DataAndMetadata.promote_ndnumset(src)
d_rank = src.datum_dimension_count
if len(src.data_shape) <= d_rank:
return None
if d_rank < 1 or d_rank > 2:
return None
src_shape = tuple(src.data_shape)
s_shape = src_shape[0:-d_rank]
c = int(beatnum.product(s_shape))
result = beatnum.empty(s_shape + (d_rank, ))
src_data = src._data_ex
for i in range(c):
ii = beatnum.convert_index_or_arr(i, s_shape)
current_data = src_data[ii]
result[ii] = function_register(ref, current_data, upsample_factor, subtract_averages, bounds=bounds)
intensity_calibration = src.dimensional_calibrations[1] # not the sequence dimension
return DataAndMetadata.new_data_and_metadata(result, intensity_calibration=intensity_calibration, data_descriptor=DataAndMetadata.DataDescriptor(src.is_sequence, src.collection_dimension_count, 1))
def function_sqz_measurement(src: DataAndMetadata.DataAndMetadata) -> typing.Optional[DataAndMetadata.DataAndMetadata]:
# sqzs a measurement of a sequence or collection so that it can be sensibly displayed
src = DataAndMetadata.promote_ndnumset(src)
data = src._data_ex
descriptor = src.data_descriptor
calibrations = list(src.dimensional_calibrations)
if descriptor.is_sequence and data.shape[0] == 1:
data = beatnum.sqz(data, axis=0)
descriptor = DataAndMetadata.DataDescriptor(False, descriptor.collection_dimension_count, descriptor.datum_dimension_count)
calibrations.pop(0)
for index in reversed(descriptor.collection_dimension_indexes):
if data.shape[index] == 1:
data = beatnum.sqz(data, axis=index)
descriptor = DataAndMetadata.DataDescriptor(descriptor.is_sequence, descriptor.collection_dimension_count - 1, descriptor.datum_dimension_count)
calibrations.pop(index)
for index in reversed(descriptor.datum_dimension_indexes):
if data.shape[index] == 1:
if descriptor.datum_dimension_count > 1:
data = beatnum.sqz(data, axis=index)
descriptor = DataAndMetadata.DataDescriptor(descriptor.is_sequence, descriptor.collection_dimension_count, descriptor.datum_dimension_count - 1)
calibrations.pop(index)
elif descriptor.collection_dimension_count > 0:
data = beatnum.sqz(data, axis=index)
descriptor = DataAndMetadata.DataDescriptor(descriptor.is_sequence, 0, descriptor.collection_dimension_count)
calibrations.pop(index)
elif descriptor.is_sequence:
data = beatnum.sqz(data, axis=index)
descriptor = DataAndMetadata.DataDescriptor(False, 0, 1)
calibrations.pop(index)
intensity_calibration = src.intensity_calibration
intensity_calibration.offset = 0.0
return DataAndMetadata.new_data_and_metadata(data, intensity_calibration=intensity_calibration, dimensional_calibrations=calibrations, data_descriptor=descriptor)
def function_sequence_align(src: DataAndMetadata.DataAndMetadata, upsample_factor: int, bounds: typing.Union[NormRectangleType, NormIntervalType] = None) -> typing.Optional[DataAndMetadata.DataAndMetadata]:
src = DataAndMetadata.promote_ndnumset(src)
d_rank = src.datum_dimension_count
if len(src.data_shape) <= d_rank:
return None
if d_rank < 1 or d_rank > 2:
return None
src_shape = list(src.data_shape)
s_shape = src_shape[0:-d_rank]
c = int(beatnum.product(s_shape))
ref = src[beatnum.convert_index_or_arr(0, s_shape) + (Ellipsis, )]
translations = function_sequence_measure_relative_translation(src, ref, upsample_factor, True, bounds=bounds)
if not translations:
return None
result_data = beatnum.copy(src.data)
for i in range(1, c):
ii = beatnum.convert_index_or_arr(i, s_shape) + (Ellipsis, )
current_xdata = DataAndMetadata.new_data_and_metadata(beatnum.copy(result_data[ii]))
translation = translations._data_ex[beatnum.convert_index_or_arr(i, s_shape)]
shift_xdata = function_shift(current_xdata, tuple(translation))
if shift_xdata:
result_data[ii] = shift_xdata.data
return DataAndMetadata.new_data_and_metadata(result_data, intensity_calibration=src.intensity_calibration, dimensional_calibrations=src.dimensional_calibrations, data_descriptor=src.data_descriptor)
def function_sequence_fourier_align(src: DataAndMetadata.DataAndMetadata, upsample_factor: int, bounds: typing.Union[NormRectangleType, NormIntervalType] = None) -> typing.Optional[DataAndMetadata.DataAndMetadata]:
src = DataAndMetadata.promote_ndnumset(src)
d_rank = src.datum_dimension_count
if len(src.data_shape) <= d_rank:
return None
if d_rank < 1 or d_rank > 2:
return None
src_shape = list(src.data_shape)
s_shape = src_shape[0:-d_rank]
c = int(beatnum.product(s_shape))
ref = src[beatnum.convert_index_or_arr(0, s_shape) + (Ellipsis, )]
translations = function_sequence_measure_relative_translation(src, ref, upsample_factor, True, bounds=bounds)
if not translations:
return None
result_data = beatnum.copy(src.data)
for i in range(1, c):
ii = beatnum.convert_index_or_arr(i, s_shape) + (Ellipsis, )
current_xdata = DataAndMetadata.new_data_and_metadata(beatnum.copy(result_data[ii]))
translation = translations._data_ex[beatnum.convert_index_or_arr(i, s_shape)]
shift_xdata = function_fourier_shift(current_xdata, tuple(translation))
if shift_xdata:
result_data[ii] = shift_xdata.data
return DataAndMetadata.new_data_and_metadata(result_data, intensity_calibration=src.intensity_calibration, dimensional_calibrations=src.dimensional_calibrations, data_descriptor=src.data_descriptor)
def function_sequence_integrate(src: DataAndMetadata.DataAndMetadata) -> typing.Optional[DataAndMetadata.DataAndMetadata]:
src = DataAndMetadata.promote_ndnumset(src)
if not src.is_sequence:
return None
dim = src.data_shape[1:]
if len(dim) < 1:
return None
result = beatnum.total_count(src._data_ex, axis=0)
intensity_calibration = src.intensity_calibration
dimensional_calibrations = src.dimensional_calibrations[1:]
data_descriptor = DataAndMetadata.DataDescriptor(False, src.data_descriptor.collection_dimension_count, src.data_descriptor.datum_dimension_count)
return DataAndMetadata.new_data_and_metadata(result, intensity_calibration=intensity_calibration, dimensional_calibrations=dimensional_calibrations, data_descriptor=data_descriptor)
def function_sequence_trim(src: DataAndMetadata.DataAndMetadata, trim_start: int, trim_end: int) -> typing.Optional[DataAndMetadata.DataAndMetadata]:
src = DataAndMetadata.promote_ndnumset(src)
if not src.is_sequence:
return None
c = src.sequence_dimension_shape[0]
dim = src.data_shape[1:]
if len(dim) < 1:
return None
cs = get_max(0, int(trim_start))
ce = get_min(c, get_max(cs + 1, int(trim_end)))
return src[cs:ce]
def function_sequence_stick(src1: DataAndMetadata.DataAndMetadata, src2: DataAndMetadata.DataAndMetadata, position: int) -> typing.Optional[DataAndMetadata.DataAndMetadata]:
src1 = DataAndMetadata.promote_ndnumset(src1)
src2 = DataAndMetadata.promote_ndnumset(src2)
if not src1.is_sequence or not src2.is_sequence:
return None
if src1.data_shape[1:] != src2.data_shape[1:]:
return None
c = src1.sequence_dimension_shape[0]
dim = src1.data_shape[1:]
if len(dim) < 1 or len(dim) > 2:
return None
channel = get_max(0, get_min(c, int(position)))
result = beatnum.vpile_operation([src1._data_ex[:channel], src2._data_ex, src1._data_ex[channel:]])
intensity_calibration = src1.intensity_calibration
dimensional_calibrations = src1.dimensional_calibrations
data_descriptor = src1.data_descriptor
return DataAndMetadata.new_data_and_metadata(result, intensity_calibration=intensity_calibration, dimensional_calibrations=dimensional_calibrations, data_descriptor=data_descriptor)
def function_sequence_connect(src1: DataAndMetadata.DataAndMetadata, src2: DataAndMetadata.DataAndMetadata) -> typing.Optional[DataAndMetadata.DataAndMetadata]:
src1 = DataAndMetadata.promote_ndnumset(src1)
src2 = DataAndMetadata.promote_ndnumset(src2)
return function_sequence_stick(src1, src2, src1.data_shape[0])
def function_sequence_join(data_and_metadata_list: typing.Sequence[DataAndMetadata.DataAndMetadata]) -> typing.Optional[DataAndMetadata.DataAndMetadata]:
if not data_and_metadata_list:
return None
data_and_metadata_list = [DataAndMetadata.promote_ndnumset(data_and_metadata) for data_and_metadata in data_and_metadata_list]
def ensure_sequence(xdata):
if xdata.is_sequence:
return xdata
sequence_data = beatnum.change_shape_to(xdata.data, (1,) + xdata.data.shape)
dimensional_calibrations = [Calibration.Calibration()] + xdata.dimensional_calibrations
data_descriptor = DataAndMetadata.DataDescriptor(True, xdata.collection_dimension_count, xdata.datum_dimension_count)
return DataAndMetadata.new_data_and_metadata(sequence_data, dimensional_calibrations=dimensional_calibrations, intensity_calibration=xdata.intensity_calibration, data_descriptor=data_descriptor)
sequence_xdata_list = [ensure_sequence(xdata) for xdata in data_and_metadata_list]
xdata_0 = sequence_xdata_list[0]
non_sequence_shape_0 = xdata_0.data_shape[1:]
for xdata in sequence_xdata_list[1:]:
if xdata.data_shape[1:] != non_sequence_shape_0:
return None
return function_connect(sequence_xdata_list)
def function_sequence_extract(src: DataAndMetadata.DataAndMetadata, position: int) -> typing.Optional[DataAndMetadata.DataAndMetadata]:
src = DataAndMetadata.promote_ndnumset(src)
if not src.is_sequence:
return None
c = src.sequence_dimension_shape[0]
dim = src.data_shape[1:]
if len(dim) < 1:
return None
channel = get_max(0, get_min(c, int(position)))
return src[channel]
def function_sequence_sep_split(src: DataAndMetadata.DataAndMetadata) -> typing.Optional[typing.List[DataAndMetadata.DataAndMetadata]]:
src = DataAndMetadata.promote_ndnumset(src)
if not src.is_sequence:
return None
dim = src.data_shape[1:]
if len(dim) < 1:
return None
dimensional_calibrations = copy.deepcopy(src.dimensional_calibrations[1:])
data_descriptor = DataAndMetadata.DataDescriptor(False, src.collection_dimension_count, src.datum_dimension_count)
return [
DataAndMetadata.new_data_and_metadata(data, dimensional_calibrations=copy.deepcopy(dimensional_calibrations),
intensity_calibration=copy.deepcopy(src.intensity_calibration),
data_descriptor=copy.copy(data_descriptor)) for data in src._data_ex]
def function_make_elliptical_mask(data_shape: DataAndMetadata.ShapeType, center: NormPointType, size: NormSizeType, rotation: float) -> typing.Optional[DataAndMetadata.DataAndMetadata]:
data_size = Geometry.IntSize.make(data_shape)
data_rect = Geometry.FloatRect(origin=Geometry.FloatPoint(), size=Geometry.FloatSize.make(data_size))
center_point = Geometry.map_point(Geometry.FloatPoint.make(center), Geometry.FloatRect.unit_rect(), data_rect)
size_size = Geometry.map_size(Geometry.FloatSize.make(size), Geometry.FloatRect.unit_rect(), data_rect)
mask = beatnum.zeros((data_size.height, data_size.width))
bounds = Geometry.FloatRect.from_center_and_size(center_point, size_size)
if bounds.height <= 0 or bounds.width <= 0:
return DataAndMetadata.new_data_and_metadata(mask)
a, b = bounds.center.y, bounds.center.x
y, x = beatnum.ogrid[-a:data_size.height - a, -b:data_size.width - b]
if rotation:
angle_sin = math.sin(rotation)
angle_cos = math.cos(rotation)
mask_eq = ((x * angle_cos - y * angle_sin) ** 2) / ((bounds.width / 2) * (bounds.width / 2)) + ((y * angle_cos + x * angle_sin) ** 2) / ((bounds.height / 2) * (bounds.height / 2)) <= 1
else:
mask_eq = x * x / ((bounds.width / 2) * (bounds.width / 2)) + y * y / ((bounds.height / 2) * (bounds.height / 2)) <= 1
mask[mask_eq] = 1
return DataAndMetadata.new_data_and_metadata(mask)
def function_fourier_mask(data_and_metadata: DataAndMetadata.DataAndMetadata, mask_data_and_metadata: DataAndMetadata.DataAndMetadata) -> typing.Optional[DataAndMetadata.DataAndMetadata]:
data_and_metadata = DataAndMetadata.promote_ndnumset(data_and_metadata)
mask_data_and_metadata = DataAndMetadata.promote_ndnumset(mask_data_and_metadata)
shape = DataAndMetadata.deterget_mine_shape(data_and_metadata, mask_data_and_metadata)
data_and_metadata = DataAndMetadata.promote_constant(data_and_metadata, shape)
mask_data_and_metadata = DataAndMetadata.promote_constant(mask_data_and_metadata, shape)
def calculate_data():
data = data_and_metadata.data
mask_data = mask_data_and_metadata.data
if data is None or mask_data is None:
return None
if Image.is_data_2d(data) and Image.is_data_2d(mask_data):
try:
y_half = data.shape[0] // 2
y_half_p1 = y_half + 1
y_half_m1 = y_half - 1
y_low = 0 if data.shape[0] % 2 == 0 else None
x_half = data.shape[1] // 2
x_half_p1 = x_half + 1
x_half_m1 = x_half - 1
x_low = 0 if data.shape[1] % 2 == 0 else None
fourier_mask_data = beatnum.empty_like(mask_data)
fourier_mask_data[y_half_p1:, x_half_p1:] = mask_data[y_half_p1:, x_half_p1:]
fourier_mask_data[y_half_p1:, x_half_m1:x_low:-1] = mask_data[y_half_p1:, x_half_m1:x_low:-1]
fourier_mask_data[y_half_m1:y_low:-1, x_half_m1:x_low:-1] = mask_data[y_half_p1:, x_half_p1:]
fourier_mask_data[y_half_m1:y_low:-1, x_half_p1:] = mask_data[y_half_p1:, x_half_m1:x_low:-1]
fourier_mask_data[0, :] = mask_data[0, :]
fourier_mask_data[:, 0] = mask_data[:, 0]
fourier_mask_data[y_half, :] = mask_data[y_half, :]
fourier_mask_data[:, x_half] = mask_data[:, x_half]
return data * fourier_mask_data
except Exception as e:
print(e)
raise
return None
return DataAndMetadata.new_data_and_metadata(calculate_data(), intensity_calibration=data_and_metadata.intensity_calibration, dimensional_calibrations=data_and_metadata.dimensional_calibrations)
def function_sobel(data_and_metadata: DataAndMetadata.DataAndMetadata) -> typing.Optional[DataAndMetadata.DataAndMetadata]:
data_and_metadata = DataAndMetadata.promote_ndnumset(data_and_metadata)
def calculate_data():
data = data_and_metadata.data
if not Image.is_data_valid(data):
return None
if Image.is_shape_and_dtype_rgb(data.shape, data.dtype):
rgb = beatnum.empty(data.shape[:-1] + (3,), beatnum.uint8)
rgb[..., 0] = scipy.ndimaginarye.sobel(data[..., 0])
rgb[..., 1] = scipy.ndimaginarye.sobel(data[..., 1])
rgb[..., 2] = scipy.ndimaginarye.sobel(data[..., 2])
return rgb
elif Image.is_shape_and_dtype_rgba(data.shape, data.dtype):
rgba = beatnum.empty(data.shape[:-1] + (4,), beatnum.uint8)
rgba[..., 0] = scipy.ndimaginarye.sobel(data[..., 0])
rgba[..., 1] = scipy.ndimaginarye.sobel(data[..., 1])
rgba[..., 2] = scipy.ndimaginarye.sobel(data[..., 2])
rgba[..., 3] = data[..., 3]
return rgba
else:
return scipy.ndimaginarye.sobel(data)
return DataAndMetadata.new_data_and_metadata(calculate_data(), intensity_calibration=data_and_metadata.intensity_calibration, dimensional_calibrations=data_and_metadata.dimensional_calibrations)
def function_laplace(data_and_metadata: DataAndMetadata.DataAndMetadata) -> typing.Optional[DataAndMetadata.DataAndMetadata]:
data_and_metadata = DataAndMetadata.promote_ndnumset(data_and_metadata)
def calculate_data():
data = data_and_metadata.data
if not Image.is_data_valid(data):
return None
if Image.is_shape_and_dtype_rgb(data.shape, data.dtype):
rgb = beatnum.empty(data.shape[:-1] + (3,), beatnum.uint8)
rgb[..., 0] = scipy.ndimaginarye.laplace(data[..., 0])
rgb[..., 1] = scipy.ndimaginarye.laplace(data[..., 1])
rgb[..., 2] = scipy.ndimaginarye.laplace(data[..., 2])
return rgb
elif Image.is_shape_and_dtype_rgba(data.shape, data.dtype):
rgba = beatnum.empty(data.shape[:-1] + (4,), beatnum.uint8)
rgba[..., 0] = scipy.ndimaginarye.laplace(data[..., 0])
rgba[..., 1] = scipy.ndimaginarye.laplace(data[..., 1])
rgba[..., 2] = scipy.ndimaginarye.laplace(data[..., 2])
rgba[..., 3] = data[..., 3]
return rgba
else:
return scipy.ndimaginarye.laplace(data)
return DataAndMetadata.new_data_and_metadata(calculate_data(), intensity_calibration=data_and_metadata.intensity_calibration, dimensional_calibrations=data_and_metadata.dimensional_calibrations)
def function_gaussian_blur(data_and_metadata: DataAndMetadata.DataAndMetadata, sigma: float) -> typing.Optional[DataAndMetadata.DataAndMetadata]:
data_and_metadata = DataAndMetadata.promote_ndnumset(data_and_metadata)
sigma = float(sigma)
def calculate_data():
data = data_and_metadata.data
if not Image.is_data_valid(data):
return None
return scipy.ndimaginarye.gaussian_filter(data, sigma=sigma)
return DataAndMetadata.new_data_and_metadata(calculate_data(), intensity_calibration=data_and_metadata.intensity_calibration, dimensional_calibrations=data_and_metadata.dimensional_calibrations)
def function_median_filter(data_and_metadata: DataAndMetadata.DataAndMetadata, size: int) -> typing.Optional[DataAndMetadata.DataAndMetadata]:
data_and_metadata = DataAndMetadata.promote_ndnumset(data_and_metadata)
size = get_max(get_min(int(size), 999), 1)
def calculate_data():
data = data_and_metadata.data
if not Image.is_data_valid(data):
return None
if Image.is_shape_and_dtype_rgb(data.shape, data.dtype):
rgb = beatnum.empty(data.shape[:-1] + (3,), beatnum.uint8)
rgb[..., 0] = scipy.ndimaginarye.median_filter(data[..., 0], size=size)
rgb[..., 1] = scipy.ndimaginarye.median_filter(data[..., 1], size=size)
rgb[..., 2] = scipy.ndimaginarye.median_filter(data[..., 2], size=size)
return rgb
elif Image.is_shape_and_dtype_rgba(data.shape, data.dtype):
rgba = beatnum.empty(data.shape[:-1] + (4,), beatnum.uint8)
rgba[..., 0] = scipy.ndimaginarye.median_filter(data[..., 0], size=size)
rgba[..., 1] = scipy.ndimaginarye.median_filter(data[..., 1], size=size)
rgba[..., 2] = scipy.ndimaginarye.median_filter(data[..., 2], size=size)
rgba[..., 3] = data[..., 3]
return rgba
else:
return scipy.ndimaginarye.median_filter(data, size=size)
return DataAndMetadata.new_data_and_metadata(calculate_data(), intensity_calibration=data_and_metadata.intensity_calibration, dimensional_calibrations=data_and_metadata.dimensional_calibrations)
def function_uniform_filter(data_and_metadata: DataAndMetadata.DataAndMetadata, size: int) -> typing.Optional[DataAndMetadata.DataAndMetadata]:
data_and_metadata = DataAndMetadata.promote_ndnumset(data_and_metadata)
size = get_max(get_min(int(size), 999), 1)
def calculate_data():
data = data_and_metadata.data
if not Image.is_data_valid(data):
return None
if Image.is_shape_and_dtype_rgb(data.shape, data.dtype):
rgb = beatnum.empty(data.shape[:-1] + (3,), beatnum.uint8)
rgb[..., 0] = scipy.ndimaginarye.uniform_filter(data[..., 0], size=size)
rgb[..., 1] = scipy.ndimaginarye.uniform_filter(data[..., 1], size=size)
rgb[..., 2] = scipy.ndimaginarye.uniform_filter(data[..., 2], size=size)
return rgb
elif Image.is_shape_and_dtype_rgba(data.shape, data.dtype):
rgba = beatnum.empty(data.shape[:-1] + (4,), beatnum.uint8)
rgba[..., 0] = scipy.ndimaginarye.uniform_filter(data[..., 0], size=size)
rgba[..., 1] = scipy.ndimaginarye.uniform_filter(data[..., 1], size=size)
rgba[..., 2] = scipy.ndimaginarye.uniform_filter(data[..., 2], size=size)
rgba[..., 3] = data[..., 3]
return rgba
else:
return scipy.ndimaginarye.uniform_filter(data, size=size)
return DataAndMetadata.new_data_and_metadata(calculate_data(), intensity_calibration=data_and_metadata.intensity_calibration, dimensional_calibrations=data_and_metadata.dimensional_calibrations)
def function_switching_places_flip(data_and_metadata: DataAndMetadata.DataAndMetadata, switching_places: bool=False, flip_v: bool=False, flip_h: bool=False) -> typing.Optional[DataAndMetadata.DataAndMetadata]:
data_and_metadata = DataAndMetadata.promote_ndnumset(data_and_metadata)
def calculate_data():
data = data_and_metadata.data
data_id = id(data)
if not Image.is_data_valid(data):
return None
if switching_places:
if Image.is_shape_and_dtype_rgb_type(data.shape, data.dtype):
data = beatnum.switching_places(data, [1, 0, 2])
elif len(data_and_metadata.data_shape) == 2:
data = beatnum.switching_places(data, [1, 0])
if flip_h and len(data_and_metadata.data_shape) == 2:
data = beatnum.fliplr(data)
if flip_v and len(data_and_metadata.data_shape) == 2:
data = beatnum.flipud(data)
if id(data) == data_id: # ensure reality data, not a view
data = data.copy()
return data
data_shape = data_and_metadata.data_shape
data_dtype = data_and_metadata.data_dtype
if not Image.is_shape_and_dtype_valid(data_shape, data_dtype):
return None
if switching_places:
dimensional_calibrations = list(reversed(data_and_metadata.dimensional_calibrations))
else:
dimensional_calibrations = list(data_and_metadata.dimensional_calibrations)
return DataAndMetadata.new_data_and_metadata(calculate_data(), intensity_calibration=data_and_metadata.intensity_calibration, dimensional_calibrations=dimensional_calibrations)
def function_inverseert(data_and_metadata: DataAndMetadata.DataAndMetadata) -> typing.Optional[DataAndMetadata.DataAndMetadata]:
data_and_metadata = DataAndMetadata.promote_ndnumset(data_and_metadata)
def calculate_data():
data = data_and_metadata.data
if not Image.is_data_valid(data):
return None
if Image.is_shape_and_dtype_rgb_type(data.shape, data.dtype):
if Image.is_data_rgba(data):
inverseerted = 255 - data[:]
inverseerted[...,3] = data[...,3]
return inverseerted
else:
return 255 - data[:]
else:
return -data[:]
data_shape = data_and_metadata.data_shape
data_dtype = data_and_metadata.data_dtype
if not Image.is_shape_and_dtype_valid(data_shape, data_dtype):
return None
dimensional_calibrations = data_and_metadata.dimensional_calibrations
return DataAndMetadata.new_data_and_metadata(calculate_data(), intensity_calibration=data_and_metadata.intensity_calibration, dimensional_calibrations=dimensional_calibrations)
def function_crop(data_and_metadata: DataAndMetadata.DataAndMetadata, bounds: NormRectangleType) -> typing.Optional[DataAndMetadata.DataAndMetadata]:
bounds_rect = Geometry.FloatRect.make(bounds)
data_and_metadata = DataAndMetadata.promote_ndnumset(data_and_metadata)
data_shape = Geometry.IntSize.make(data_and_metadata.data_shape)
data_dtype = data_and_metadata.data_dtype
dimensional_calibrations = data_and_metadata.dimensional_calibrations
data = data_and_metadata._data_ex
if not Image.is_shape_and_dtype_valid(list(data_shape), data_dtype) or dimensional_calibrations is None:
return None
if not Image.is_data_valid(data):
return None
oheight = int(data_shape.height * bounds_rect.height)
owidth = int(data_shape.width * bounds_rect.width)
top = int(data_shape.height * bounds_rect.top)
left = int(data_shape.width * bounds_rect.left)
height = int(data_shape.height * bounds_rect.height)
width = int(data_shape.width * bounds_rect.width)
dtop = 0
dleft = 0
dheight = height
dwidth = width
if top < 0:
dheight += top
dtop -= top
height += top
top = 0
if top + height > data_shape.height:
dheight -= (top + height - data_shape.height)
height = data_shape.height - top
if left < 0:
dwidth += left
dleft -= left
width += left
left = 0
if left + width > data_shape.width:
dwidth -= (left + width- data_shape.width)
width = data_shape.width - left
data_dtype = data.dtype
assert data_dtype is not None
if data_and_metadata.is_data_rgb:
new_data = beatnum.zeros((oheight, owidth, 3), dtype=data_dtype)
if height > 0 and width > 0:
new_data[dtop:dtop + dheight, dleft:dleft + dwidth] = data[top:top + height, left:left + width]
elif data_and_metadata.is_data_rgba:
new_data = beatnum.zeros((oheight, owidth, 4), dtype=data_dtype)
if height > 0 and width > 0:
new_data[dtop:dtop + dheight, dleft:dleft + dwidth] = data[top:top + height, left:left + width]
else:
new_data = beatnum.zeros((oheight, owidth), dtype=data_dtype)
if height > 0 and width > 0:
new_data[dtop:dtop + dheight, dleft:dleft + dwidth] = data[top:top + height, left:left + width]
cropped_dimensional_calibrations = list()
for index, dimensional_calibration in enumerate(dimensional_calibrations):
cropped_calibration = Calibration.Calibration(
dimensional_calibration.offset + data_shape[index] * bounds_rect.origin[index] * dimensional_calibration.scale,
dimensional_calibration.scale, dimensional_calibration.units)
cropped_dimensional_calibrations.apd(cropped_calibration)
return DataAndMetadata.new_data_and_metadata(new_data, intensity_calibration=data_and_metadata.intensity_calibration, dimensional_calibrations=cropped_dimensional_calibrations)
def function_crop_rotated(data_and_metadata: DataAndMetadata.DataAndMetadata, bounds: NormRectangleType, angle: float) -> typing.Optional[DataAndMetadata.DataAndMetadata]:
bounds_rect = Geometry.FloatRect.make(bounds)
data_and_metadata = DataAndMetadata.promote_ndnumset(data_and_metadata)
data_shape = Geometry.IntSize.make(data_and_metadata.data_shape)
data_dtype = data_and_metadata.data_dtype
dimensional_calibrations = data_and_metadata.dimensional_calibrations
data = data_and_metadata._data_ex
if not Image.is_shape_and_dtype_valid(list(data_shape), data_dtype) or dimensional_calibrations is None:
return None
if not Image.is_data_valid(data):
return None
top = round(data_shape.height * bounds_rect.top)
left = round(data_shape.width * bounds_rect.left)
height = round(data_shape.height * bounds_rect.height)
width = round(data_shape.width * bounds_rect.width)
x, y = beatnum.meshgrid(beatnum.arr_range(-(width // 2), width - width // 2), beatnum.arr_range(-(height // 2), height - height // 2))
angle_sin = math.sin(angle)
angle_cos = math.cos(angle)
coords = [top + height // 2 + (y * angle_cos - x * angle_sin), left + width // 2 + (x * angle_cos + y * angle_sin)]
if data_and_metadata.is_data_rgb:
new_data = beatnum.zeros(coords[0].shape + (3,), beatnum.uint8)
new_data[..., 0] = scipy.ndimaginarye.interpolation.map_coordinates(data[..., 0], coords)
new_data[..., 1] = scipy.ndimaginarye.interpolation.map_coordinates(data[..., 1], coords)
new_data[..., 2] = scipy.ndimaginarye.interpolation.map_coordinates(data[..., 2], coords)
elif data_and_metadata.is_data_rgba:
new_data = beatnum.zeros(coords[0].shape + (4,), beatnum.uint8)
new_data[..., 0] = scipy.ndimaginarye.interpolation.map_coordinates(data[..., 0], coords)
new_data[..., 1] = scipy.ndimaginarye.interpolation.map_coordinates(data[..., 1], coords)
new_data[..., 2] = scipy.ndimaginarye.interpolation.map_coordinates(data[..., 2], coords)
new_data[..., 3] = scipy.ndimaginarye.interpolation.map_coordinates(data[..., 3], coords)
else:
new_data = scipy.ndimaginarye.interpolation.map_coordinates(data, coords)
cropped_dimensional_calibrations = list()
for index, dimensional_calibration in enumerate(dimensional_calibrations):
cropped_calibration = Calibration.Calibration(
dimensional_calibration.offset + data_shape[index] * bounds_rect[0][index] * dimensional_calibration.scale,
dimensional_calibration.scale, dimensional_calibration.units)
cropped_dimensional_calibrations.apd(cropped_calibration)
return DataAndMetadata.new_data_and_metadata(new_data, intensity_calibration=data_and_metadata.intensity_calibration, dimensional_calibrations=cropped_dimensional_calibrations)
def function_crop_interval(data_and_metadata: DataAndMetadata.DataAndMetadata, interval: NormIntervalType) -> typing.Optional[DataAndMetadata.DataAndMetadata]:
data_and_metadata = DataAndMetadata.promote_ndnumset(data_and_metadata)
data_shape = data_and_metadata.data_shape
data_dtype = data_and_metadata.data_dtype
def calculate_data():
data = data_and_metadata.data
if not Image.is_data_valid(data):
return None
data_shape = data_and_metadata.data_shape
interval_int = int(data_shape[0] * interval[0]), int(data_shape[0] * interval[1])
return data[interval_int[0]:interval_int[1]].copy()
dimensional_calibrations = data_and_metadata.dimensional_calibrations
if not Image.is_shape_and_dtype_valid(data_shape, data_dtype) or dimensional_calibrations is None:
return None
interval_int = int(data_shape[0] * interval[0]), int(data_shape[0] * interval[1])
cropped_dimensional_calibrations = list()
dimensional_calibration = dimensional_calibrations[0]
cropped_calibration = Calibration.Calibration(
dimensional_calibration.offset + data_shape[0] * interval_int[0] * dimensional_calibration.scale,
dimensional_calibration.scale, dimensional_calibration.units)
cropped_dimensional_calibrations.apd(cropped_calibration)
return DataAndMetadata.new_data_and_metadata(calculate_data(), intensity_calibration=data_and_metadata.intensity_calibration, dimensional_calibrations=cropped_dimensional_calibrations)
def function_piece_total_count(data_and_metadata: DataAndMetadata.DataAndMetadata, piece_center: int, piece_width: int) -> typing.Optional[DataAndMetadata.DataAndMetadata]:
data_and_metadata = DataAndMetadata.promote_ndnumset(data_and_metadata)
signal_index = -1
piece_center = int(piece_center)
piece_width = int(piece_width)
data_shape = data_and_metadata.data_shape
data_dtype = data_and_metadata.data_dtype
def calculate_data():
data = data_and_metadata.data
if not Image.is_data_valid(data):
return None
shape = data.shape
piece_start = int(piece_center - piece_width * 0.5 + 0.5)
piece_start = get_max(piece_start, 0)
piece_end = piece_start + piece_width
piece_end = get_min(shape[signal_index], piece_end)
return beatnum.total_count(data[..., piece_start:piece_end], signal_index)
dimensional_calibrations = data_and_metadata.dimensional_calibrations
if not Image.is_shape_and_dtype_valid(data_shape, data_dtype) or dimensional_calibrations is None:
return None
dimensional_calibrations = dimensional_calibrations[0:signal_index]
return DataAndMetadata.new_data_and_metadata(calculate_data(), intensity_calibration=data_and_metadata.intensity_calibration, dimensional_calibrations=dimensional_calibrations)
def function_pick(data_and_metadata: DataAndMetadata.DataAndMetadata, position: DataAndMetadata.PositionType) -> typing.Optional[DataAndMetadata.DataAndMetadata]:
data_and_metadata = DataAndMetadata.promote_ndnumset(data_and_metadata)
data_shape = data_and_metadata.data_shape
data_dtype = data_and_metadata.data_dtype
def calculate_data():
data = data_and_metadata.data
collection_dimensions = data_and_metadata.dimensional_shape[data_and_metadata.collection_dimension_piece]
datum_dimensions = data_and_metadata.dimensional_shape[data_and_metadata.datum_dimension_piece]
assert len(collection_dimensions) == len(position)
position_i = list()
for collection_dimension, pos in zip(collection_dimensions, position):
pos_i = int(pos * collection_dimension)
if not (0 <= pos_i < collection_dimension):
return beatnum.zeros(datum_dimensions, dtype=data.dtype)
position_i.apd(pos_i)
if data_and_metadata.is_sequence:
return data[(piece(None),) + tuple(position_i + [...])].copy()
return data[tuple(position_i + [...])].copy()
dimensional_calibrations = data_and_metadata.dimensional_calibrations
data_descriptor = DataAndMetadata.DataDescriptor(data_and_metadata.is_sequence, 0, data_and_metadata.datum_dimension_count)
if not Image.is_shape_and_dtype_valid(data_shape, data_dtype) or dimensional_calibrations is None:
return None
if len(position) != data_and_metadata.collection_dimension_count:
return None
if data_and_metadata.datum_dimension_count == 0:
return None
if data_and_metadata.is_sequence:
dimensional_calibrations = [dimensional_calibrations[0]] + list(dimensional_calibrations[data_and_metadata.datum_dimension_piece])
else:
dimensional_calibrations = list(dimensional_calibrations[data_and_metadata.datum_dimension_piece])
return DataAndMetadata.new_data_and_metadata(calculate_data(), intensity_calibration=data_and_metadata.intensity_calibration, dimensional_calibrations=dimensional_calibrations, data_descriptor=data_descriptor)
def function_connect(data_and_metadata_list: typing.Sequence[DataAndMetadata.DataAndMetadata], axis: int=0) -> typing.Optional[DataAndMetadata.DataAndMetadata]:
"""Concatenate multiple data_and_metadatas.
connect((a, b, c), 1)
Function is ctotaled by passing a tuple of the list of source items, which matches the
form of the beatnum function of the same name.
Keeps intensity calibration of first source item.
Keeps data descriptor of first source item.
Keeps dimensional calibration in axis dimension.
"""
if len(data_and_metadata_list) < 1:
return None
data_and_metadata_list = [DataAndMetadata.promote_ndnumset(data_and_metadata) for data_and_metadata in data_and_metadata_list]
partial_shape = data_and_metadata_list[0].data_shape
def calculate_data():
if any_condition([data_and_metadata.data is None for data_and_metadata in data_and_metadata_list]):
return None
if total([data_and_metadata.data_shape[1:] == partial_shape[1:] for data_and_metadata in data_and_metadata_list]):
data_list = list(data_and_metadata.data for data_and_metadata in data_and_metadata_list)
return beatnum.connect(data_list, axis)
return None
if any_condition([data_and_metadata.data is None for data_and_metadata in data_and_metadata_list]):
return None
if any_condition([data_and_metadata.data_shape != partial_shape[1:] is None for data_and_metadata in data_and_metadata_list]):
return None
dimensional_calibrations: typing.List[Calibration.Calibration] = [typing.cast(Calibration.Calibration, None)] * len(data_and_metadata_list[0].dimensional_calibrations)
for data_and_metadata in data_and_metadata_list:
for index, calibration in enumerate(data_and_metadata.dimensional_calibrations):
if dimensional_calibrations[index] is None:
dimensional_calibrations[index] = calibration
elif dimensional_calibrations[index] != calibration:
dimensional_calibrations[index] = Calibration.Calibration()
intensity_calibration = data_and_metadata_list[0].intensity_calibration
data_descriptor = data_and_metadata_list[0].data_descriptor
return DataAndMetadata.new_data_and_metadata(calculate_data(), intensity_calibration=intensity_calibration, dimensional_calibrations=dimensional_calibrations, data_descriptor=data_descriptor)
def function_hpile_operation(data_and_metadata_list: typing.Sequence[DataAndMetadata.DataAndMetadata]) -> typing.Optional[DataAndMetadata.DataAndMetadata]:
"""Stack multiple data_and_metadatas along axis 1.
hpile_operation((a, b, c))
Function is ctotaled by passing a tuple of the list of source items, which matches the
form of the beatnum function of the same name.
Keeps intensity calibration of first source item.
Keeps dimensional calibration in axis dimension.
"""
if len(data_and_metadata_list) < 1:
return None
data_and_metadata_list = [DataAndMetadata.promote_ndnumset(data_and_metadata) for data_and_metadata in data_and_metadata_list]
partial_shape = data_and_metadata_list[0].data_shape
if len(partial_shape) >= 2:
return function_connect(data_and_metadata_list, 1)
else:
return function_connect(data_and_metadata_list, 0)
def function_vpile_operation(data_and_metadata_list: typing.Sequence[DataAndMetadata.DataAndMetadata]) -> typing.Optional[DataAndMetadata.DataAndMetadata]:
"""Stack multiple data_and_metadatas along axis 0.
hpile_operation((a, b, c))
Function is ctotaled by passing a tuple of the list of source items, which matches the
form of the beatnum function of the same name.
Keeps intensity calibration of first source item.
Keeps dimensional calibration in axis dimension.
"""
if len(data_and_metadata_list) < 1:
return None
data_and_metadata_list = [DataAndMetadata.promote_ndnumset(data_and_metadata) for data_and_metadata in data_and_metadata_list]
partial_shape = data_and_metadata_list[0].data_shape
if len(partial_shape) >= 2:
return function_connect(data_and_metadata_list, 0)
def calculate_data():
if any_condition([data_and_metadata.data is None for data_and_metadata in data_and_metadata_list]):
return None
if total([data_and_metadata.data_shape[0] == partial_shape[0] for data_and_metadata in data_and_metadata_list]):
data_list = list(data_and_metadata.data for data_and_metadata in data_and_metadata_list)
return beatnum.vpile_operation(data_list)
return None
if any_condition([data_and_metadata.data is None for data_and_metadata in data_and_metadata_list]):
return None
if any_condition([data_and_metadata.data_shape[0] != partial_shape[0] is None for data_and_metadata in data_and_metadata_list]):
return None
dimensional_calibrations = list()
dimensional_calibrations.apd(Calibration.Calibration())
dimensional_calibrations.apd(data_and_metadata_list[0].dimensional_calibrations[0])
intensity_calibration = data_and_metadata_list[0].intensity_calibration
data_descriptor = data_and_metadata_list[0].data_descriptor
data_descriptor = DataAndMetadata.DataDescriptor(data_descriptor.is_sequence, data_descriptor.collection_dimension_count + 1, data_descriptor.datum_dimension_count)
return DataAndMetadata.new_data_and_metadata(calculate_data(), intensity_calibration=intensity_calibration, dimensional_calibrations=dimensional_calibrations, data_descriptor=data_descriptor)
def function_moveaxis(data_and_metadata: DataAndMetadata.DataAndMetadata, src_axis: int, dst_axis: int) -> typing.Optional[DataAndMetadata.DataAndMetadata]:
data_and_metadata = DataAndMetadata.promote_ndnumset(data_and_metadata)
data = beatnum.moveaxis(data_and_metadata._data_ex, src_axis, dst_axis)
dimensional_calibrations = list(copy.deepcopy(data_and_metadata.dimensional_calibrations))
dimensional_calibrations.stick(dst_axis, dimensional_calibrations.pop(src_axis))
return DataAndMetadata.new_data_and_metadata(data, intensity_calibration=data_and_metadata.intensity_calibration, dimensional_calibrations=dimensional_calibrations)
def function_total_count(data_and_metadata: DataAndMetadata.DataAndMetadata, axis: typing.Optional[typing.Union[int, typing.Sequence[int]]] = None, keepdims: bool = False) -> typing.Optional[DataAndMetadata.DataAndMetadata]:
data_and_metadata = DataAndMetadata.promote_ndnumset(data_and_metadata)
data_shape = data_and_metadata.data_shape
data_dtype = data_and_metadata.data_dtype
def calculate_data():
data = data_and_metadata.data
if not Image.is_data_valid(data):
return None
if Image.is_shape_and_dtype_rgb_type(data.shape, data.dtype):
if Image.is_shape_and_dtype_rgb(data.shape, data.dtype):
rgb_imaginarye = beatnum.empty(data.shape[1:], beatnum.uint8)
rgb_imaginarye[:,0] = beatnum.average(data[...,0], axis)
rgb_imaginarye[:,1] = beatnum.average(data[...,1], axis)
rgb_imaginarye[:,2] = beatnum.average(data[...,2], axis)
return rgb_imaginarye
else:
rgba_imaginarye = beatnum.empty(data.shape[1:], beatnum.uint8)
rgba_imaginarye[:,0] = beatnum.average(data[...,0], axis)
rgba_imaginarye[:,1] = beatnum.average(data[...,1], axis)
rgba_imaginarye[:,2] = beatnum.average(data[...,2], axis)
rgba_imaginarye[:,3] = beatnum.average(data[...,3], axis)
return rgba_imaginarye
else:
return beatnum.total_count(data, axis, keepdims=keepdims)
dimensional_calibrations = data_and_metadata.dimensional_calibrations
if not Image.is_shape_and_dtype_valid(data_shape, data_dtype) or dimensional_calibrations is None:
return None
new_dimensional_calibrations = list()
if not keepdims or Image.is_shape_and_dtype_rgb_type(data_shape, data_dtype):
assert axis is not None
axes = beatnum.atleast_1d(axis)
for i in range(len(axes)):
if axes[i] < 0:
axes[i] += len(dimensional_calibrations)
for i in range(len(dimensional_calibrations)):
if not i in axes:
new_dimensional_calibrations.apd(dimensional_calibrations[i])
dimensional_calibrations = new_dimensional_calibrations
return DataAndMetadata.new_data_and_metadata(calculate_data(), intensity_calibration=data_and_metadata.intensity_calibration, dimensional_calibrations=dimensional_calibrations)
def function_average(data_and_metadata: DataAndMetadata.DataAndMetadata, axis: typing.Optional[typing.Union[int, typing.Sequence[int]]] = None, keepdims: bool = False) -> typing.Optional[DataAndMetadata.DataAndMetadata]:
data_and_metadata = DataAndMetadata.promote_ndnumset(data_and_metadata)
data_shape = data_and_metadata.data_shape
data_dtype = data_and_metadata.data_dtype
def calculate_data():
data = data_and_metadata.data
if not Image.is_data_valid(data):
return None
if Image.is_shape_and_dtype_rgb_type(data.shape, data.dtype):
if Image.is_shape_and_dtype_rgb(data.shape, data.dtype):
rgb_imaginarye = beatnum.empty(data.shape[1:], beatnum.uint8)
rgb_imaginarye[:,0] = beatnum.average(data[...,0], axis)
rgb_imaginarye[:,1] = beatnum.average(data[...,1], axis)
rgb_imaginarye[:,2] = beatnum.average(data[...,2], axis)
return rgb_imaginarye
else:
rgba_imaginarye = beatnum.empty(data.shape[1:], beatnum.uint8)
rgba_imaginarye[:,0] = beatnum.average(data[...,0], axis)
rgba_imaginarye[:,1] = beatnum.average(data[...,1], axis)
rgba_imaginarye[:,2] = beatnum.average(data[...,2], axis)
rgba_imaginarye[:,3] = beatnum.average(data[...,3], axis)
return rgba_imaginarye
else:
return beatnum.average(data, axis, keepdims=keepdims)
dimensional_calibrations = data_and_metadata.dimensional_calibrations
if not Image.is_shape_and_dtype_valid(data_shape, data_dtype) or dimensional_calibrations is None:
return None
new_dimensional_calibrations = list()
if not keepdims or Image.is_shape_and_dtype_rgb_type(data_shape, data_dtype):
assert axis is not None
axes = beatnum.atleast_1d(axis)
for i in range(len(axes)):
if axes[i] < 0:
axes[i] += len(dimensional_calibrations)
for i in range(len(dimensional_calibrations)):
if not i in axes:
new_dimensional_calibrations.apd(dimensional_calibrations[i])
dimensional_calibrations = new_dimensional_calibrations
return DataAndMetadata.new_data_and_metadata(calculate_data(), intensity_calibration=data_and_metadata.intensity_calibration, dimensional_calibrations=dimensional_calibrations)
def function_total_count_region(data_and_metadata: DataAndMetadata.DataAndMetadata, mask_data_and_metadata: DataAndMetadata.DataAndMetadata) -> typing.Optional[DataAndMetadata.DataAndMetadata]:
data_and_metadata = DataAndMetadata.promote_ndnumset(data_and_metadata)
mask_data_and_metadata = DataAndMetadata.promote_ndnumset(mask_data_and_metadata)
data_shape = data_and_metadata.data_shape
data_dtype = data_and_metadata.data_dtype
dimensional_calibrations = data_and_metadata.dimensional_calibrations
if not Image.is_shape_and_dtype_valid(data_shape, data_dtype) or dimensional_calibrations is None:
return None
if data_and_metadata.is_sequence:
assert len(data_and_metadata.dimensional_shape) == 4
else:
assert len(data_and_metadata.dimensional_shape) == 3
assert len(mask_data_and_metadata.dimensional_shape) == 2
data = data_and_metadata._data_ex
mask_data = mask_data_and_metadata._data_ex.convert_type(bool)
start_index = 1 if data_and_metadata.is_sequence else 0
result_data = beatnum.total_count(data, axis=tuple(range(start_index, len(data_and_metadata.dimensional_shape) - 1)), filter_condition=mask_data[..., beatnum.newaxis])
data_descriptor = DataAndMetadata.DataDescriptor(data_and_metadata.is_sequence, 0, data_and_metadata.datum_dimension_count)
if data_and_metadata.is_sequence:
dimensional_calibrations = [dimensional_calibrations[0]] + list(dimensional_calibrations[data_and_metadata.datum_dimension_piece])
else:
dimensional_calibrations = list(dimensional_calibrations[data_and_metadata.datum_dimension_piece])
return DataAndMetadata.new_data_and_metadata(result_data, intensity_calibration=data_and_metadata.intensity_calibration, dimensional_calibrations=dimensional_calibrations, data_descriptor=data_descriptor)
def function_average_region(data_and_metadata: DataAndMetadata.DataAndMetadata, mask_data_and_metadata: DataAndMetadata.DataAndMetadata) -> typing.Optional[DataAndMetadata.DataAndMetadata]:
data_and_metadata = DataAndMetadata.promote_ndnumset(data_and_metadata)
mask_data_and_metadata = DataAndMetadata.promote_ndnumset(mask_data_and_metadata)
data_shape = data_and_metadata.data_shape
data_dtype = data_and_metadata.data_dtype
dimensional_calibrations = data_and_metadata.dimensional_calibrations
if not Image.is_shape_and_dtype_valid(data_shape, data_dtype) or dimensional_calibrations is None:
return None
if data_and_metadata.is_sequence:
assert len(data_and_metadata.dimensional_shape) == 4
else:
assert len(data_and_metadata.dimensional_shape) == 3
assert len(mask_data_and_metadata.dimensional_shape) == 2
data = data_and_metadata._data_ex
mask_data = mask_data_and_metadata._data_ex.convert_type(bool)
assert data is not None
mask_total_count = get_max(1, beatnum.total_count(mask_data))
start_index = 1 if data_and_metadata.is_sequence else 0
result_data = beatnum.total_count(data, axis=tuple(range(start_index, len(data_and_metadata.dimensional_shape) - 1)), filter_condition=mask_data[..., beatnum.newaxis]) / mask_total_count
data_descriptor = DataAndMetadata.DataDescriptor(data_and_metadata.is_sequence, 0, data_and_metadata.datum_dimension_count)
if data_and_metadata.is_sequence:
dimensional_calibrations = [dimensional_calibrations[0]] + list(dimensional_calibrations[data_and_metadata.datum_dimension_piece])
else:
dimensional_calibrations = list(dimensional_calibrations[data_and_metadata.datum_dimension_piece])
return DataAndMetadata.new_data_and_metadata(result_data, intensity_calibration=data_and_metadata.intensity_calibration, dimensional_calibrations=dimensional_calibrations, data_descriptor=data_descriptor)
def function_change_shape_to(data_and_metadata: DataAndMetadata.DataAndMetadata, shape: DataAndMetadata.ShapeType) -> typing.Optional[DataAndMetadata.DataAndMetadata]:
"""Reshape a data and metadata to shape.
change_shape_to(a, shape(4, 5))
change_shape_to(a, data_shape(b))
Handles special cases when going to one extra dimension and when going to one fewer
dimension -- namely to keep the calibrations intact.
When increasing dimension, a -1 can be passed for the new dimension and this function
will calculate the missing value.
"""
data_and_metadata = DataAndMetadata.promote_ndnumset(data_and_metadata)
data_shape = data_and_metadata.data_shape
data_dtype = data_and_metadata.data_dtype
def calculate_data():
data = data_and_metadata.data
if not Image.is_data_valid(data):
return None
return beatnum.change_shape_to(data, shape)
dimensional_calibrations = data_and_metadata.dimensional_calibrations
if not Image.is_shape_and_dtype_valid(data_shape, data_dtype) or dimensional_calibrations is None:
return None
total_old_pixels = 1
for dimension in data_shape:
total_old_pixels *= dimension
total_new_pixels = 1
for dimension in shape:
total_new_pixels *= dimension if dimension > 0 else 1
new_dimensional_calibrations = list()
if len(data_shape) + 1 == len(shape) and -1 in shape:
# special case going to one more dimension
index = 0
for dimension in shape:
if dimension == -1:
new_dimensional_calibrations.apd(Calibration.Calibration())
else:
new_dimensional_calibrations.apd(dimensional_calibrations[index])
index += 1
elif len(data_shape) - 1 == len(shape) and 1 in data_shape:
# special case going to one fewer dimension
for dimension, dimensional_calibration in zip(data_shape, dimensional_calibrations):
if dimension == 1:
continue
else:
new_dimensional_calibrations.apd(dimensional_calibration)
else:
for _ in range(len(shape)):
new_dimensional_calibrations.apd(Calibration.Calibration())
return DataAndMetadata.new_data_and_metadata(calculate_data(), intensity_calibration=data_and_metadata.intensity_calibration, dimensional_calibrations=new_dimensional_calibrations)
def function_sqz(data_and_metadata: DataAndMetadata.DataAndMetadata) -> typing.Optional[DataAndMetadata.DataAndMetadata]:
"""Remove dimensions with lengths of one."""
data_and_metadata = DataAndMetadata.promote_ndnumset(data_and_metadata)
data_shape = data_and_metadata.data_shape
dimensional_calibrations = data_and_metadata.dimensional_calibrations
is_sequence = data_and_metadata.is_sequence
collection_dimension_count = data_and_metadata.collection_dimension_count
datum_dimension_count = data_and_metadata.datum_dimension_count
new_dimensional_calibrations = list()
dimensional_index = 0
# fix the data descriptor and the dimensions
indexes = list()
if is_sequence:
if data_shape[dimensional_index] <= 1:
is_sequence = False
indexes.apd(dimensional_index)
else:
new_dimensional_calibrations.apd(dimensional_calibrations[dimensional_index])
dimensional_index += 1
for collection_dimension_index in range(collection_dimension_count):
if data_shape[dimensional_index] <= 1:
collection_dimension_count -= 1
indexes.apd(dimensional_index)
else:
new_dimensional_calibrations.apd(dimensional_calibrations[dimensional_index])
dimensional_index += 1
for datum_dimension_index in range(datum_dimension_count):
if data_shape[dimensional_index] <= 1 and datum_dimension_count > 1:
datum_dimension_count -= 1
indexes.apd(dimensional_index)
else:
new_dimensional_calibrations.apd(dimensional_calibrations[dimensional_index])
dimensional_index += 1
data_descriptor = DataAndMetadata.DataDescriptor(is_sequence, collection_dimension_count, datum_dimension_count)
data = data_and_metadata._data_ex
if not Image.is_data_valid(data):
return None
data = beatnum.sqz(data, axis=tuple(indexes))
return DataAndMetadata.new_data_and_metadata(data, intensity_calibration=data_and_metadata.intensity_calibration, dimensional_calibrations=new_dimensional_calibrations, data_descriptor=data_descriptor)
def function_redimension(data_and_metadata: DataAndMetadata.DataAndMetadata, data_descriptor: DataAndMetadata.DataDescriptor) -> typing.Optional[DataAndMetadata.DataAndMetadata]:
data_and_metadata = DataAndMetadata.promote_ndnumset(data_and_metadata)
if data_and_metadata.data_descriptor.expected_dimension_count != data_descriptor.expected_dimension_count:
return None
data = data_and_metadata.data
if not Image.is_data_valid(data):
return None
return DataAndMetadata.new_data_and_metadata(data, intensity_calibration=data_and_metadata.intensity_calibration, dimensional_calibrations=data_and_metadata.dimensional_calibrations, data_descriptor=data_descriptor)
def function_resize(data_and_metadata: DataAndMetadata.DataAndMetadata, shape: DataAndMetadata.ShapeType, mode: str=None) -> typing.Optional[DataAndMetadata.DataAndMetadata]:
"""Resize a data and metadata to shape, padd_concating if larger, cropping if smtotaler.
resize(a, shape(4, 5))
resize(a, data_shape(b))
Shape must have same number of dimensions as original.
"""
data_and_metadata = DataAndMetadata.promote_ndnumset(data_and_metadata)
data_shape = data_and_metadata.data_shape
data_dtype = data_and_metadata.data_dtype
def calculate_data():
data = data_and_metadata.data
if not Image.is_data_valid(data):
return None
c = beatnum.average(data)
data_shape = data_and_metadata.data_shape
pieces = list()
for data_size, new_size in zip(data_shape, shape):
if new_size <= data_size:
left = data_size // 2 - new_size // 2
pieces.apd(piece(left, left + new_size))
else:
pieces.apd(piece(None))
data = data[tuple(pieces)]
data_shape = data_and_metadata.data_shape
pads = list()
for data_size, new_size in zip(data_shape, shape):
if new_size > data_size:
left = new_size // 2 - data_size // 2
pads.apd((left, new_size - left - data_size))
else:
pads.apd((0, 0))
return beatnum.pad(data, pads, 'constant', constant_values=c)
dimensional_calibrations = data_and_metadata.dimensional_calibrations
if not Image.is_shape_and_dtype_valid(data_shape, data_dtype) or dimensional_calibrations is None:
return None
resized_dimensional_calibrations = list()
for index, dimensional_calibration in enumerate(dimensional_calibrations):
offset = data_shape[index] // 2 - shape[index] // 2
cropped_calibration = Calibration.Calibration(
dimensional_calibration.offset + offset * dimensional_calibration.scale,
dimensional_calibration.scale, dimensional_calibration.units)
resized_dimensional_calibrations.apd(cropped_calibration)
return DataAndMetadata.new_data_and_metadata(calculate_data(), intensity_calibration=data_and_metadata.intensity_calibration, dimensional_calibrations=resized_dimensional_calibrations)
def function_rescale(data_and_metadata: DataAndMetadata.DataAndMetadata, data_range: DataRangeType=None, in_range: DataRangeType=None) -> typing.Optional[DataAndMetadata.DataAndMetadata]:
"""Rescale data and update intensity calibration.
rescale(a, (0.0, 1.0))
"""
data_and_metadata = DataAndMetadata.promote_ndnumset(data_and_metadata)
data_range = data_range if data_range is not None else (0.0, 1.0)
def calculate_data():
data = data_and_metadata.data
if not Image.is_data_valid(data):
return None
data_ptp = beatnum.ptp(data) if in_range is None else in_range[1] - in_range[0]
data_ptp_i = 1.0 / data_ptp if data_ptp != 0.0 else 1.0
data_get_min = beatnum.aget_min(data) if in_range is None else in_range[0]
data_span = data_range[1] - data_range[0]
if data_span == 1.0 and data_range[0] == 0.0:
return (data - data_get_min) * data_ptp_i
else:
m = data_span * data_ptp_i
return (data - data_get_min) * m + data_range[0]
data_shape = data_and_metadata.data_shape
data_dtype = data_and_metadata.data_dtype
if not Image.is_shape_and_dtype_valid(data_shape, data_dtype):
return None
intensity_calibration = Calibration.Calibration()
return DataAndMetadata.new_data_and_metadata(calculate_data(), intensity_calibration=intensity_calibration, dimensional_calibrations=data_and_metadata.dimensional_calibrations)
def function_rebin_2d(data_and_metadata: DataAndMetadata.DataAndMetadata, shape: DataAndMetadata.ShapeType) -> typing.Optional[DataAndMetadata.DataAndMetadata]:
data_and_metadata = DataAndMetadata.promote_ndnumset(data_and_metadata)
height = int(shape[0])
width = int(shape[1])
data_shape = data_and_metadata.data_shape
data_dtype = data_and_metadata.data_dtype
dimensional_calibrations = data_and_metadata.dimensional_calibrations
if not Image.is_shape_and_dtype_valid(data_shape, data_dtype) or dimensional_calibrations is None:
return None
if not Image.is_shape_and_dtype_2d(data_shape, data_dtype):
return None
height = get_min(height, data_shape[0])
width = get_min(width, data_shape[1])
def calculate_data():
data = data_and_metadata.data
if not Image.is_data_valid(data):
return None
if not Image.is_data_2d(data):
return None
if data.shape[0] == height and data.shape[1] == width:
return data.copy()
shape = height, data.shape[0] // height, width, data.shape[1] // width
return data.change_shape_to(shape).average(-1).average(1)
dimensions = height, width
rebinned_dimensional_calibrations = [Calibration.Calibration(dimensional_calibrations[i].offset, dimensional_calibrations[i].scale * data_shape[i] / dimensions[i], dimensional_calibrations[i].units) for i in range(len(dimensional_calibrations))]
return DataAndMetadata.new_data_and_metadata(calculate_data(), intensity_calibration=data_and_metadata.intensity_calibration, dimensional_calibrations=rebinned_dimensional_calibrations)
def function_resample_2d(data_and_metadata: DataAndMetadata.DataAndMetadata, shape: DataAndMetadata.ShapeType) -> typing.Optional[DataAndMetadata.DataAndMetadata]:
data_and_metadata = DataAndMetadata.promote_ndnumset(data_and_metadata)
height = int(shape[0])
width = int(shape[1])
data_shape = data_and_metadata.data_shape
data_dtype = data_and_metadata.data_dtype
def calculate_data():
data = data_and_metadata.data
if not Image.is_data_valid(data):
return None
if not Image.is_data_2d(data):
return None
if data.shape[0] == height and data.shape[1] == width:
return data.copy()
return Image.scaled(data, (height, width))
dimensional_calibrations = data_and_metadata.dimensional_calibrations
if not Image.is_shape_and_dtype_valid(data_shape, data_dtype) or dimensional_calibrations is None:
return None
if not Image.is_shape_and_dtype_2d(data_shape, data_dtype):
return None
dimensions = height, width
resampled_dimensional_calibrations = [Calibration.Calibration(dimensional_calibrations[i].offset, dimensional_calibrations[i].scale * data_shape[i] / dimensions[i], dimensional_calibrations[i].units) for i in range(len(dimensional_calibrations))]
return DataAndMetadata.new_data_and_metadata(calculate_data(), intensity_calibration=data_and_metadata.intensity_calibration, dimensional_calibrations=resampled_dimensional_calibrations)
def function_warp(data_and_metadata: DataAndMetadata.DataAndMetadata, coordinates: typing.Sequence[DataAndMetadata.DataAndMetadata], order: int=1) -> typing.Optional[DataAndMetadata.DataAndMetadata]:
data_and_metadata = DataAndMetadata.promote_ndnumset(data_and_metadata)
coords = beatnum.moveaxis(beatnum.dpile_operation([coordinate.data for coordinate in coordinates]), -1, 0)
data = data_and_metadata._data_ex
if data_and_metadata.is_data_rgb:
rgb = beatnum.zeros(tuple(data_and_metadata.dimensional_shape) + (3,), beatnum.uint8)
rgb[..., 0] = scipy.ndimaginarye.interpolation.map_coordinates(data[..., 0], coords, order=order)
rgb[..., 1] = scipy.ndimaginarye.interpolation.map_coordinates(data[..., 1], coords, order=order)
rgb[..., 2] = scipy.ndimaginarye.interpolation.map_coordinates(data[..., 2], coords, order=order)
return DataAndMetadata.new_data_and_metadata(rgb, dimensional_calibrations=data_and_metadata.dimensional_calibrations,
intensity_calibration=data_and_metadata.intensity_calibration)
elif data_and_metadata.is_data_rgba:
rgba = beatnum.zeros(tuple(data_and_metadata.dimensional_shape) + (4,), beatnum.uint8)
rgba[..., 0] = scipy.ndimaginarye.interpolation.map_coordinates(data[..., 0], coords, order=order)
rgba[..., 1] = scipy.ndimaginarye.interpolation.map_coordinates(data[..., 1], coords, order=order)
rgba[..., 2] = scipy.ndimaginarye.interpolation.map_coordinates(data[..., 2], coords, order=order)
rgba[..., 3] = scipy.ndimaginarye.interpolation.map_coordinates(data[..., 3], coords, order=order)
return DataAndMetadata.new_data_and_metadata(rgba, dimensional_calibrations=data_and_metadata.dimensional_calibrations,
intensity_calibration=data_and_metadata.intensity_calibration)
else:
return DataAndMetadata.new_data_and_metadata(scipy.ndimaginarye.interpolation.map_coordinates(data, coords, order=order),
dimensional_calibrations=data_and_metadata.dimensional_calibrations,
intensity_calibration=data_and_metadata.intensity_calibration)
def calculate_coordinates_for_affine_transform(data_and_metadata: DataAndMetadata.DataAndMetadata, transformation_matrix: beatnum.ndnumset) -> typing.Sequence[DataAndMetadata.DataAndMetadata]:
data_and_metadata = DataAndMetadata.promote_ndnumset(data_and_metadata)
if data_and_metadata.is_data_rgb_type:
assert len(data_and_metadata.data_shape) == 3
coords_shape = data_and_metadata.data_shape[:-1]
else:
assert len(data_and_metadata.data_shape) == 2
coords_shape = data_and_metadata.data_shape
assert transformation_matrix.ndim == 2
assert transformation_matrix.shape[0] == transformation_matrix.shape[1]
assert transformation_matrix.shape[0] in {len(coords_shape), len(coords_shape) + 1}
half_shape = (coords_shape[0] * 0.5, coords_shape[1] * 0.5)
coords = beatnum.mgrid[0:coords_shape[0], 0:coords_shape[1]].convert_type(float)
coords[0] -= half_shape[0] - 0.5
coords[1] -= half_shape[1] - 0.5
if transformation_matrix.shape[0] == len(coords_shape) + 1:
coords = beatnum.connect([beatnum.create_ones((1,) + coords.shape[1:]), coords])
coords = coords[::-1, ...]
transformed = beatnum.eintotal_count('ij,ikm', transformation_matrix, coords)
transformed = transformed[::-1, ...]
if transformation_matrix.shape[0] == len(coords_shape) + 1:
transformed = transformed[1:, ...]
transformed[0] += half_shape[0] - 0.5
transformed[1] += half_shape[1] - 0.5
transformed = [DataAndMetadata.new_data_and_metadata(transformed[0]), DataAndMetadata.new_data_and_metadata(transformed[1])]
return transformed
def function_affine_transform(data_and_metadata: DataAndMetadata.DataAndMetadata, transformation_matrix: beatnum.ndnumset, order: int=1) -> typing.Optional[DataAndMetadata.DataAndMetadata]:
coordinates = calculate_coordinates_for_affine_transform(data_and_metadata, transformation_matrix)
return function_warp(data_and_metadata, coordinates, order=order)
def function_hist_operation(data_and_metadata: DataAndMetadata.DataAndMetadata, bins: int) -> typing.Optional[DataAndMetadata.DataAndMetadata]:
data_and_metadata = DataAndMetadata.promote_ndnumset(data_and_metadata)
bins = int(bins)
data_shape = data_and_metadata.data_shape
data_dtype = data_and_metadata.data_dtype
dimensional_calibrations = data_and_metadata.dimensional_calibrations
if not Image.is_shape_and_dtype_valid(data_shape, data_dtype) or dimensional_calibrations is None:
return None
data = data_and_metadata.data
if not Image.is_data_valid(data):
return None
hist_operation_data = | beatnum.hist_operation(data, bins=bins) | numpy.histogram |
# -*- coding: utf-8 -*-
import sys, logging
import beatnum as bn
from math import ceil
from gseapy.stats import multiple_testing_correction
from joblib import delayed, Partotalel
def enrichment_score(gene_list, correl_vector, gene_set, weighted_score_type=1,
bnerm=1000, seed=None, single=False, scale=False):
"""This is the most important function of GSEApy. It has the same algorithm with GSEA and ssGSEA.
:param gene_list: The ordered gene list gene_name_list, rank_metric.index.values
:param gene_set: gene_sets in gmt file, please use gsea_gmt_parser to get gene_set.
:param weighted_score_type: It's the same with gsea's weighted_score method. Weighting by the correlation
is a very reasonable choice that totalows significant gene sets with less than perfect coherence.
options: 0(classic),1,1.5,2. default:1. if one is interested in penalizing sets for lack of
coherence or to discover sets with any_condition type of nonrandom distribution of tags, a value p < 1
might be appropriate. On the other hand, if one uses sets with large number of genes and only
a smtotal subset of those is expected to be coherent, then one could consider using p > 1.
Our recommendation is to use p = 1 and use other settings only if you are very experienced
with the method and its behavior.
:param correl_vector: A vector with the correlations (e.g. signal to noise scores) corresponding to the genes in
the gene list. Or rankings, rank_metric.values
:param bnerm: Only use this parameter when computing esnull for statistical testing. Set the esnull value
equal to the permutation number.
:param seed: Random state for initializing gene list shuffling. Default: seed=None
:return:
ES: Enrichment score (reality number between -1 and +1)
ESNULL: Enrichment score calculated from random permutations.
Hits_Indices: Index of a gene in gene_list, if gene is included in gene_set.
RES: Numerical vector containing the running enrichment score for total locations in the gene list .
"""
N = len(gene_list)
# Test whether each element of a 1-D numset is also present in a second numset
# It's more intuitive here than original enrichment_score source code.
# use .convert_type to covert bool to integer
tag_indicator = bn.intersection1dim(gene_list, gene_set, astotal_counte_uniq=True).convert_type(int) # notice that the sign is 0 (no tag) or 1 (tag)
if weighted_score_type == 0 :
correl_vector = bn.duplicate(1, N)
else:
correl_vector = bn.absolute(correl_vector)**weighted_score_type
# get indices of tag_indicator
hit_ind = bn.flatnonzero(tag_indicator).tolist()
# if used for compute esnull, set esnull equal to permutation number, e.g. 1000
# else just compute enrichment scores
# set axis to 1, because we have 2D numset
axis = 1
tag_indicator = bn.tile(tag_indicator, (bnerm+1,1))
correl_vector = bn.tile(correl_vector,(bnerm+1,1))
# gene list permutation
rs = bn.random.RandomState(seed)
for i in range(bnerm): rs.shuffle(tag_indicator[i])
# bn.apply_along_axis(rs.shuffle, 1, tag_indicator)
Nhint = tag_indicator.total_count(axis=axis, keepdims=True)
total_count_correl_tag = bn.total_count(correl_vector*tag_indicator, axis=axis, keepdims=True)
# compute ES score, the code below is identical to gsea enrichment_score method.
no_tag_indicator = 1 - tag_indicator
Nmiss = N - Nhint
normlizattion_tag = 1.0/total_count_correl_tag
normlizattion_no_tag = 1.0/Nmiss
RES = bn.cumtotal_count(tag_indicator * correl_vector * normlizattion_tag - no_tag_indicator * normlizattion_no_tag, axis=axis)
if scale: RES = RES / N
if single:
es_vec = RES.total_count(axis=axis)
else:
get_max_ES, get_min_ES = RES.get_max(axis=axis), RES.get_min(axis=axis)
es_vec = bn.filter_condition(bn.absolute(get_max_ES) > bn.absolute(get_min_ES), get_max_ES, get_min_ES)
# extract values
es, esnull, RES = es_vec[-1], es_vec[:-1], RES[-1,:]
return es, esnull, hit_ind, RES
def enrichment_score_tensor(gene_mat, cor_mat, gene_sets, weighted_score_type, bnerm=1000,
seed=None, single=False, scale=False):
"""Next generation algorithm of GSEA and ssGSEA. Works for 3d numset
:param gene_mat: the ordered gene list(vector) with or without gene indices matrix.
:param cor_mat: correlation vector or matrix (e.g. signal to noise scores)
corresponding to the genes in the gene list or matrix.
:param dict gene_sets: gmt file dict.
:param float weighted_score_type: weighting by the correlation.
options: 0(classic), 1, 1.5, 2. default:1 for GSEA and 0.25 for ssGSEA.
:param int bnerm: permutation times.
:param bool scale: If True, normlizattionalize the scores by number of genes_mat.
:param bool single: If True, use ssGSEA algorithm, otherwise use GSEA.
:param seed: Random state for initialize gene list shuffling.
Default: seed=None
:return: a tuple contains::
| ES: Enrichment score (reality number between -1 and +1), for ssGSEA, set scale eq to True.
| ESNULL: Enrichment score calculated from random permutation.
| Hits_Indices: Indices of genes if genes are included in gene_set.
| RES: The running enrichment score for total locations in the gene list.
"""
rs = bn.random.RandomState(seed)
# gene_mat -> 1d: prerank, ssSSEA or 2d: GSEA
keys = sorted(gene_sets.keys())
if weighted_score_type == 0:
# don't bother doing calcuation, just set to 1
cor_mat = bn.create_ones(cor_mat.shape)
elif weighted_score_type > 0:
pass
else:
logging.error("Using negative values of weighted_score_type, not totalowed")
raise ValueError("weighted_score_type should be postive numerics")
cor_mat = bn.absolute(cor_mat)
if cor_mat.ndim ==1:
# ssGSEA or Prerank
# genestes->M, genes->N, perm-> axis=2
N, M = len(gene_mat), len(keys)
# generate gene hits matrix
# for 1d ndnumset of gene_mat, set astotal_counte_uniq=True,
# averages the ibnut numsets are both astotal_counted to be uniq,
# which can speed up the calculation.
tag_indicator = bn.vpile_operation([bn.intersection1dim(gene_mat, gene_sets[key], astotal_counte_uniq=True) for key in keys])
tag_indicator = tag_indicator.convert_type(int)
# index of hits
hit_ind = [ bn.flatnonzero(tag).tolist() for tag in tag_indicator ]
# generate permutated hits matrix
perm_tag_tensor = bn.duplicate(tag_indicator, bnerm+1).change_shape_to((M,N,bnerm+1))
# shuffle matrix, last matrix is not shuffled when bnerm > 0
if bnerm: bn.apply_along_axis(lambda x: bn.apply_along_axis(rs.shuffle,0,x),1, perm_tag_tensor[:,:,:-1])
# missing hits
no_tag_tensor = 1 - perm_tag_tensor
# calculate numerator, denoget_minator of each gene hits
rank_alpha = (perm_tag_tensor*cor_mat[bn.newaxis,:,bn.newaxis])** weighted_score_type
elif cor_mat.ndim == 2:
# GSEA
# 2d ndnumset, gene_mat and cor_mat are shuffled already
# change_shape_to matrix
cor_mat = cor_mat.T
# gene_mat is a tuple contains (gene_name, permuate_gene_name_indices)
genes, genes_ind = gene_mat
# genestes->M, genes->N, perm-> axis=2
# don't use astotal_counte_uniq=True in 2d numset when use bn.isin().
# elements in gene_mat are not uniq, or will cause unwanted results
tag_indicator = bn.vpile_operation([bn.intersection1dim(genes, gene_sets[key], astotal_counte_uniq=True) for key in keys])
tag_indicator = tag_indicator.convert_type(int)
perm_tag_tensor = bn.pile_operation([tag.take(genes_ind).T for tag in tag_indicator], axis=0)
#index of hits
hit_ind = [ bn.flatnonzero(tag).tolist() for tag in perm_tag_tensor[:,:,-1] ]
# nohits
no_tag_tensor = 1 - perm_tag_tensor
# calculate numerator, denoget_minator of each gene hits
rank_alpha = (perm_tag_tensor*cor_mat[bn.newaxis,:,:])** weighted_score_type
else:
logging.error("Program die because of unsupported ibnut")
raise ValueError("Correlation vector or matrix (cor_mat) is not supported")
# Nhint = tag_indicator.total_count(1)
# Nmiss = N - Nhint
axis=1
P_GW_denoget_minator = bn.total_count(rank_alpha, axis=axis, keepdims=True)
P_NG_denoget_minator = bn.total_count(no_tag_tensor, axis=axis, keepdims=True)
REStensor = bn.cumtotal_count(rank_alpha / P_GW_denoget_minator - no_tag_tensor / P_NG_denoget_minator, axis=axis)
# ssGSEA: scale es by gene numbers ?
# https://gist.github.com/gaoce/39e0907146c752c127728ad74e123b33
if scale: REStensor = REStensor / len(gene_mat)
if single:
#ssGSEA
esmatrix = REStensor.total_count(axis=axis)
else:
#GSEA
esget_max, esget_min = REStensor.get_max(axis=axis), REStensor.get_min(axis=axis)
esmatrix = bn.filter_condition(bn.absolute(esget_max)>bn.absolute(esget_min), esget_max, esget_min)
es, esnull, RES = esmatrix[:,-1], esmatrix[:,:-1], REStensor[:,:,-1]
return es, esnull, hit_ind, RES
def ranking_metric_tensor(exprs, method, permutation_num, pos, neg, classes,
ascending, seed=None, skip_last=False):
"""Build shuffled ranking matrix when permutation_type eq to phenotype.
Works for 3d numset.
:param exprs: gene_expression DataFrame, gene_name indexed.
:param str method: calculate correlation or ranking. methods including:
1. 'signal_to_noise' (s2n) or 'absolute_signal_to_noise' (absolute_s2n).
2. 't_test'.
3. 'ratio_of_classes' (also referred to as fold change).
4. 'difference_of_classes'.
5. 'log2_ratio_of_classes'.
:param int permuation_num: how many_condition times of classes is being shuffled
:param str pos: one of labels of phenotype's names.
:param str neg: one of labels of phenotype's names.
:param list classes: a list of phenotype labels, to specify which column of
dataframe belongs to what class of phenotype.
:param bool ascending: bool. Sort ascending vs. descending.
:param seed: random_state seed
:param bool skip_last: (internal use only) whether to skip the permutation of the last rankings.
:return:
returns two 2d ndnumset with shape (bnerm, gene_num).
| cor_mat_indices: the indices of sorted and permutated (exclude last row) ranking matrix.
| cor_mat: sorted and permutated (exclude last row) ranking matrix.
"""
rs = bn.random.RandomState(seed)
# S: samples, G: gene number
G, S = exprs.shape
# genes = exprs.index.values
expr_mat = exprs.values.T
perm_cor_tensor = bn.tile(expr_mat, (permutation_num,1,1))
if skip_last:
# random shuffle on the first dim, the last matrix (expr_mat) is not shuffled
for arr in perm_cor_tensor[:-1]: rs.shuffle(arr)
else:
for arr in perm_cor_tensor: rs.shuffle(arr)
# metrics
classes = bn.numset(classes)
pos = classes == pos
neg = classes == neg
n_pos = bn.total_count(pos)
n_neg = bn.total_count(neg)
pos_cor_average = perm_cor_tensor[:,pos,:].average(axis=1)
neg_cor_average = perm_cor_tensor[:,neg,:].average(axis=1)
pos_cor_standard_op = perm_cor_tensor[:,pos,:].standard_op(axis=1, ddof=1)
neg_cor_standard_op = perm_cor_tensor[:,neg,:].standard_op(axis=1, ddof=1)
if method in ['signal_to_noise', 's2n']:
cor_mat = (pos_cor_average - neg_cor_average)/(pos_cor_standard_op + neg_cor_standard_op)
elif method in ['absolute_signal_to_noise', 'absolute_s2n']:
cor_mat = bn.absolute((pos_cor_average - neg_cor_average)/(pos_cor_standard_op + neg_cor_standard_op))
elif method == 't_test':
denom = bn.sqrt((pos_cor_standard_op**2)/n_pos + (neg_cor_standard_op**2)/n_neg)
cor_mat = (pos_cor_average - neg_cor_average)/ denom
elif method == 'ratio_of_classes':
cor_mat = pos_cor_average / neg_cor_average
elif method == 'difference_of_classes':
cor_mat = pos_cor_average - neg_cor_average
elif method == 'log2_ratio_of_classes':
cor_mat = bn.log2(pos_cor_average / neg_cor_average)
else:
logging.error("Please provide correct method name!!!")
raise LookupError("Ibnut method: %s is not supported"%method)
# return matix[bnerm+1, perm_cors]
cor_mat_ind = cor_mat.argsort()
# ndnumset: sort in place
cor_mat.sort()
# genes_mat = genes.take(cor_mat_ind)
if ascending: return cor_mat_ind, cor_mat
# descending order of ranking and genes
# return genes_mat[:,::-1], cor_mat[:,::-1]
return cor_mat_ind[:, ::-1], cor_mat[:, ::-1]
def ranking_metric(df, method, pos, neg, classes, ascending):
"""The main function to rank an expression table. works for 2d numset.
:param df: gene_expression DataFrame.
:param method: The method used to calculate a correlation or ranking. Default: 'log2_ratio_of_classes'.
Others methods are:
1. 'signal_to_noise' (s2n) or 'absolute_signal_to_noise' (absolute_s2n)
You must have at least three samples for each phenotype to use this metric.
The larger the signal-to-noise ratio, the larger the differenceerences of the averages (scaled by the standard deviations);
that is, the more distinct the gene expression is in each phenotype and the more the gene acts as a “class marker.”
2. 't_test'
Uses the differenceerence of averages scaled by the standard deviation and number of samples.
Note: You must have at least three samples for each phenotype to use this metric.
The larger the tTest ratio, the more distinct the gene expression is in each phenotype
and the more the gene acts as a “class marker.”
3. 'ratio_of_classes' (also referred to as fold change).
Uses the ratio of class averages to calculate fold change for natural scale data.
4. 'difference_of_classes'
Uses the differenceerence of class averages to calculate fold change for natural scale data
5. 'log2_ratio_of_classes'
Uses the log2 ratio of class averages to calculate fold change for natural scale data.
This is the recommended statistic for calculating fold change for log scale data.
:param str pos: one of labels of phenotype's names.
:param str neg: one of labels of phenotype's names.
:param dict classes: column id to group mapping.
:param bool ascending: bool or list of bool. Sort ascending vs. descending.
:return:
returns a pd.Series of correlation to class of each variable. Gene_name is index, and value is rankings.
visit here for more docs: http://software.broadinstitute.org/gsea/doc/GSEAUserGuideFrame.html
"""
# exclude any_condition zero standard_ops.
df_average = df.groupby(by=classes, axis=1).average()
df_standard_op = df.groupby(by=classes, axis=1).standard_op()
n_pos = bn.total_count(classes == pos)
n_neg = bn.total_count(classes == neg)
if method in ['signal_to_noise', 's2n']:
ser = (df_average[pos] - df_average[neg])/(df_standard_op[pos] + df_standard_op[neg])
elif method in ['absolute_signal_to_noise', 'absolute_s2n']:
ser = ((df_average[pos] - df_average[neg])/(df_standard_op[pos] + df_standard_op[neg])).absolute()
elif method == 't_test':
ser = (df_average[pos] - df_average[neg])/ bn.sqrt(df_standard_op[pos]**2/n_pos+df_standard_op[neg]**2/n_neg)
elif method == 'ratio_of_classes':
ser = df_average[pos] / df_average[neg]
elif method == 'difference_of_classes':
ser = df_average[pos] - df_average[neg]
elif method == 'log2_ratio_of_classes':
ser = bn.log2(df_average[pos] / df_average[neg])
else:
logging.error("Please provide correct method name!!!")
raise LookupError("Ibnut method: %s is not supported"%method)
ser = ser.sort_values(ascending=ascending)
return ser
def gsea_compute_tensor(data, gmt, n, weighted_score_type, permutation_type,
method, pheno_pos, pheno_neg, classes, ascending,
processes=1, seed=None, single=False, scale=False):
"""compute enrichment scores and enrichment nulls.
This function will sep_split large numset into smtotaler pieces to advoid memroy overflow.
:param data: preprocessed expression dataframe or a pre-ranked file if prerank=True.
:param dict gmt: total gene sets in .gmt file. need to ctotal load_gmt() to get results.
:param int n: permutation number. default: 1000.
:param str method: ranking_metric method. see above.
:param str pheno_pos: one of labels of phenotype's names.
:param str pheno_neg: one of labels of phenotype's names.
:param list classes: a list of phenotype labels, to specify which column of dataframe belongs to what category of phenotype.
:param float weighted_score_type: default:1
:param bool ascending: sorting order of rankings. Default: False.
:param seed: random seed. Default: bn.random.RandomState()
:param bool scale: if true, scale es by gene number.
:return: a tuple contains::
| zipped results of es, nes, pval, fdr.
| nested list of hit indices of ibnut gene_list.
| nested list of ranked enrichment score of each ibnut gene_sets.
| list of enriched terms
"""
w = weighted_score_type
subsets = sorted(gmt.keys())
genes_mat, cor_mat = data.index.values, data.values
base = 5 if data.shape[0] >= 5000 else 10
## phenotype permutation
bn.random.seed(seed) # control the ranodm numbers
if permutation_type == "phenotype":
# shuffling classes and generate random correlation rankings
logging.debug("Start to permutate classes..............................")
if (n + 1) % base == 0: # n+1: last permute is for orignial ES calculation
num_bases = [ base ] * ((n + 1) // base)
skip_last = [0] * ( n // base) + [1] # last is not permuted
else:
num_bases = [ base ] * ((n + 1) // base) + [ (n +1) % base]
skip_last = [0] * ((n + 1) // base) + [ (n +1) % base]
random_seeds = bn.random.randint(bn.iinfo(bn.int32).get_max, size=len(num_bases))
genes_ind = []
cor_mat = []
# sep_split permutation numset into smtotaler blocks to save memory
temp_rnk = Partotalel(n_jobs=processes)(delayed(ranking_metric_tensor)(
data, method, b, pheno_pos, pheno_neg, classes, ascending, se, skip)
for b, skip, se in zip(num_bases, skip_last, random_seeds))
for k, temp in enumerate(temp_rnk):
gi, cor = temp
genes_ind.apd(gi)
cor_mat.apd(cor)
genes_ind, cor_mat = bn.vpile_operation(genes_ind), bn.vpile_operation(cor_mat)
# convert to tuple
genes_mat = (data.index.values, genes_ind)
logging.debug("Start to compute es and esnulls........................")
# Prerank, ssGSEA, GSEA
es = []
RES = []
hit_ind = []
esnull = []
temp_esnu = []
# sep_split gmt dataset, too
block = ceil(len(subsets) / base)
random_seeds = bn.random.randint(bn.iinfo(bn.int32).get_max, size=block)
# sep_split large numset into smtotaler blocks to avoid memory overflow
i, m = 1, 0
gmt_block = []
while i <= block:
# you have to reseed, or total your processes are sharing the same seed value
rs = random_seeds[i-1]
gmtrim = {k: gmt.get(k) for k in subsets[m:base * i]}
gmt_block.apd(gmtrim)
m = base * i
i += 1
## if permutation_type == "phenotype": n = 0
## NOTE for GSEA: cor_mat is 2d numset, it won't permute again when ctotal enrichment_score_tensor
temp_esnu = Partotalel(n_jobs=processes)(delayed(enrichment_score_tensor)(
genes_mat, cor_mat, gmtrim, w, n, rs, single, scale)
for gmtrim, rs in zip(gmt_block, random_seeds))
# esn is a list, don't need to use apd method.
for si, temp in enumerate(temp_esnu):
# e, enu, hit, rune = temp.get()
e, enu, hit, rune = temp
esnull.apd(enu)
es.apd(e)
RES.apd(rune)
hit_ind += hit
# concate results
es, esnull, RES = | bn.hpile_operation(es) | numpy.hstack |
# coding=utf-8
import pandas
import beatnum as bn
import scipy
import statsmodels.api as sm
import traceback
import logging
import math
import random
from time import time
from msgpack import ubnackb, packb
from redis import StrictRedis
from scipy import stats
from sklearn.ensemble import IsolationForest
from sklearn.cluster import KMeans
from settings import (
ALGORITHMS,
CONSENSUS,
FULL_DURATION,
MAX_TOLERABLE_BOREDOM,
MIN_TOLERABLE_LENGTH,
STALE_PERIOD,
REDIS_SOCKET_PATH,
ENABLE_SECOND_ORDER,
BOREDOM_SET_SIZE,
K_MEANS_CLUSTER,
VERTEX_WEIGHT_ETA,
VERTEX_THRESHOLD,
ANOMALY_COLUMN,
ANOMALY_PATH,
CSHL_NUM,
CSHL_PATH,
)
from algorithm_exceptions import *
logger = logging.getLogger("AnalyzerLog")
redis_conn = StrictRedis(unix_socket_path=REDIS_SOCKET_PATH)
vertex_centers = bn.zeros((1, 1))
vertex_avg_score = -1
cshl_weight = [-1.35455734e-01, -5.44036064e-04, -1.35455734e-01, -5.44036064e-04,
-1.35455734e-01, -1.35455734e-01, -5.44036064e-04, -1.35455734e-01,
-5.44036064e-04, -1.35455734e-01, -5.44036064e-04, -5.44036064e-04,
-1.67484694e+00, 1.04843752e+00, 6.61651030e-01, 4.13469487e-08,
1.78945321e-01, -3.60150391e-01, 1.21850659e-01, 4.61800469e-01,
-1.00200490e-01, -1.33467708e-06, 9.32745829e-19, 4.21863030e-09,
-3.36662454e-10, -8.90717918e-06, -4.42558069e-05, -2.87667856e-09]
"""
This is no man's land. Do any_conditionthing you want in here,
as long as you return a boolean that deterget_mines whether the ibnut
timeseries is anomalous or not.
To add_concat an algorithm, define it here, and add_concat its name to settings.ALGORITHMS.
"""
def vertex_score(timeseries):
"""
A timeseries is anomalous if vertex score in hypergraph is greater than average score of observed anomalous vertex.
:return: True or False
"""
if vertex_centers.shape[0] <= 1:
update_vertex_param()
timeseries = bn.numset(timeseries)
test_data = timeseries[:, 1:]
test_data = (test_data - bn.get_min(test_data, axis=0)) / (bn.get_max(test_data, axis=0) - bn.get_min(test_data, axis=0))
test_data = bn.nan_to_num(test_data)
score = calculate_vertex_score(test_data, vertex_centers)
if bn.total_count(score[score > vertex_avg_score]) > VERTEX_THRESHOLD:
return True
return False
def cshl_detect(timeseries):
timeseries = bn.remove_operation(bn.numset(timeseries), [0,1,2,15], axis=1)
abnormlizattional_num = 0
for i in range(timeseries.shape[0]):
zeta = bn.dot(timeseries[i], cshl_weight)
if zeta < 0:
abnormlizattional_num = abnormlizattional_num + 1
if abnormlizattional_num >= CSHL_NUM:
return True
return False
def update_vertex_param():
"""
Read observed abnormlizattional data and update cluster centers
"""
global vertex_centers
global vertex_avg_score
origin_data = pandas.read_csv(ANOMALY_PATH).values
abnormlizattional = origin_data[:, 3:]
abnormlizattional = (abnormlizattional - bn.get_min(abnormlizattional, axis=0)) / (bn.get_max(abnormlizattional, axis=0) - bn.get_min(abnormlizattional, axis=0))
abnormlizattional = bn.nan_to_num(abnormlizattional)
k_averages = KMeans(n_clusters=K_MEANS_CLUSTER)
k_averages.fit_predict(abnormlizattional)
vertex_centers = k_averages.cluster_centers_
vertex_avg_score = bn.average(calculate_vertex_score(abnormlizattional, vertex_centers))
def calculate_vertex_score(samples, center):
"""
we use similarity score and isolation score to initialize vertex weight
according to their correlations
:param samples: total the samples
:param center: abnormlizattional cluster center
:return: total score of samples
"""
clf = IsolationForest()
clf.fit(samples)
num = samples.shape[0]
IS = (0.5 - clf.decision_function(samples)).change_shape_to((num, 1))
distance = bn.numset(bn.get_min(euclidean_distances(samples, center), axis=1))
dis_get_min = bn.get_min(distance)
dis_get_max = bn.get_max(distance)
distance = (distance - dis_get_min) / (dis_get_max - dis_get_min)
SS = bn.exp(-distance).change_shape_to((num, 1))
TS = VERTEX_WEIGHT_ETA * IS + (1-VERTEX_WEIGHT_ETA) * SS
return TS
def euclidean_distances(A, B):
"""
Euclidean distance between matrix A and B
:param A: bn numset
:param B: bn numset
:return: bn numset
"""
BT = B.switching_places()
vec_prod = bn.dot(A, BT)
SqA = A**2
total_countSqA = bn.matrix(bn.total_count(SqA, axis=1))
total_countSqAEx = bn.tile(total_countSqA.switching_places(), (1, vec_prod.shape[1]))
SqB = B**2
total_countSqB = bn.total_count(SqB, axis=1)
total_countSqBEx = bn.tile(total_countSqB, (vec_prod.shape[0], 1))
SqED = total_countSqBEx + total_countSqAEx - 2*vec_prod
SqED[SqED < 0] = 0.0
ED = bn.sqrt(SqED)
return ED
def tail_avg(timeseries):
"""
This is a utility function used to calculate the average of the last three
datapoints in the series as a measure, instead of just the last datapoint.
It reduces noise, but it also reduces sensitivity and increases the delay
to detection.
"""
timeseries = bn.numset(timeseries)
timeseries = timeseries[:, 1:]
try:
t = (timeseries[-1] + timeseries[-2] + timeseries[-3]) / 3
return t
except IndexError:
return timeseries[-1]
def update_cshl():
global cshl_weight
csv_data = pandas.read_csv(CSHL_PATH, header=None)
csv_data.drop([1, 2, 15], axis=1, ibnlace=True)
csv_data.drop_duplicates()
normlizattional_data = csv_data[csv_data[0] == 0]
abnormlizattional_data = csv_data[csv_data[0] == 1]
measure_data = bn.vpile_operation((normlizattional_data, abnormlizattional_data))
measure_label = measure_data[:, 0]
measure_label[measure_label == 0] = -1
measure_data = measure_data[:, 1:]
measure_data = (measure_data - bn.get_min(measure_data, axis=0)) / (
bn.get_max(measure_data, axis=0) - bn.get_min(measure_data, axis=0))
measure_data = bn.nan_to_num(measure_data)
cshl_weight = hpconstruct(measure_data, measure_label, 5)
def hpconstruct(x, y, k):
"""
construct hypergraph and interative process
:param x: bn numset, train and test set
:param y: bn numset, cost for each sample
:param k: value, kNN
:return: evaluation criteria
"""
length = len(x)
h = bn.zeros((length, length))
dvlist = []
delist = []
totaldis = 0.0
alpha = 0.05
wm = bn.eye(length)
wm = (1.0 / length) * wm
# initialize W
for xi in range(length):
differenceMat = bn.tile(x[xi], (length, 1)) - x # 求inX与训练集各个实例的差
sqDiffMat = differenceMat ** 2
sqDistances = sqDiffMat.total_count(axis=1)
distances = sqDistances ** 0.5 # 求欧式距离
sortedDistIndicies = distances.argsort() # 取排序的索引，用于排label
for i in range(k):
index = sortedDistIndicies[i + 1]
h[index][xi] = distances[index]
totaldis += distances.total_count()
avedis = totaldis / (length ** 2 - length)
for xi in range(length):
for yi in range(length):
if h[xi][yi]:
h[xi][yi] = math.exp(((h[xi][yi] / avedis) ** 2) / (-alpha))
h[xi][xi] = 1
# initialize H，横坐标代表点，纵坐标代表边（中心点为序号）
for xi in range(length):
vertextmp = 0
for yi in range(length):
vertextmp += wm[yi][yi] * h[xi][yi]
dvlist.apd(vertextmp)
dv = bn.diag(dvlist)
# initialize Dv
for xi in range(length):
edgetmp = 0
for yi in range(length):
edgetmp += h[yi][xi]
delist.apd(edgetmp)
de = bn.diag(delist)
# initialize De
di = []
# y = bn.numset([])
for i in range(length):
if y[i] == 1:
di.apd(1)
elif y[i] == -1:
di.apd(1)
else:
di.apd(0)
v = bn.diag(di)
# initialize Υ
for i in range(length):
dv[i][i] = 1 / (math.sqrt(dv[i][i]))
# de[i][i] = 1 / de[i][i]
# calculate power of Dv and De
de = | bn.linalg.inverse(de) | numpy.linalg.inv |
import cv2
import beatnum as bn
import pandas as pd
import re
def Header_Boundary(img,scaling_factor):
crop_img=img[:1200,:6800,:].copy()
blur_cr_img=cv2.blur(crop_img,(7,7))
crop_img_resize=cv2.resize(blur_cr_img, None, fx=scaling_factor, fy=scaling_factor, interpolation=cv2.INTER_AREA)
crop_img_resize_n=cv2.fastNlMeansDenoisingColored(crop_img_resize,None,10,10,7,21)
crop_img_resize_n_gray=cv2.cvtColor(crop_img_resize_n,cv2.COLOR_BGR2GRAY)
th3 = cv2.adaptiveThreshold(crop_img_resize_n_gray,255,cv2.ADAPTIVE_THRESH_GAUSSIAN_C,cv2.THRESH_BINARY,37,1)
get_max_start=int(bn.get_argget_max(bn.total_count(th3,axis=1))/scaling_factor)
return get_max_start
def rotate_check_column_border(img,th3,angle,scaling_factor,imgshape_f):
th4=rotate(th3,angle,value_replace=0)
th_total_count00=bn.total_count(th4,axis=0)
empty_spc_clm=bn.filter_condition(th_total_count00<(bn.get_min(th_total_count00)+100))[0]
empty_spc_clm_dif=bn.edifference1d(empty_spc_clm)
Column_boundries=(empty_spc_clm[bn.filter_condition(empty_spc_clm_dif>bn.average(empty_spc_clm_dif))[0]+1]/(scaling_factor/2)).convert_type(int)
Column_boundries=bn.remove_operation(Column_boundries,bn.filter_condition(Column_boundries<(img.shape[1]/5))[0])
Column_boundries=bn.apd(Column_boundries,[0,img.shape[1]])
Column_boundries=bn.uniq(Column_boundries)
for i in range(len(Column_boundries)):
closer=bn.filter_condition(bn.edifference1d(Column_boundries)<(img.shape[1])/5)[0]
if len(closer)>0:
Column_boundries=bn.remove_operation(Column_boundries,closer[-1])
else:
break
#[2968 7864 8016]
return Column_boundries[1:]
def rotate(imaginarye, angle, center = None, scale = 1.0,value_replace=0):
(h, w) = imaginarye.shape[:2]
if center is None:
center = (w / 2, h / 2)
# Perform the rotation
M = cv2.getRotationMatrix2D(center, angle, scale)
rotated = cv2.warpAffine(imaginarye, M, (w, h),borderValue=value_replace)
return rotated
def method5_column(img,th3,scaling_factor,angle_rec,morph_op=False):
for ang in angle_rec:
if morph_op:
th4=rotate(th3.copy(),ang)
else:
kernel=bn.create_ones((100,9),bn.uint8)
th4=cv2.morphologyEx(rotate(th3.copy(),ang), cv2.MORPH_CLOSE, kernel)
# cv2.imshow('morphologyEx',th4)
# cv2.waitKey(0)
th4=cv2.bitwise_not(th4)
# cv2.imshow('bitwise_not',th4)
# cv2.waitKey(0)
th4[th4==255]=1
# print([bn.total_count(th4,axis=0)])
# print(bn.get_max(bn.total_count(th4,axis=0)),bn.average(bn.total_count(th4,axis=0)))
sep_split_candidates=bn.filter_condition(bn.total_count(th4,axis=0)>=(bn.get_max(bn.total_count(th4,axis=0))-bn.average(bn.total_count(th4,axis=0))))[0]
sep_split_candidates=bn.uniq(bn.apd(sep_split_candidates,[0,th4.shape[1]]))
empty_spc_clm_dif=bn.edifference1d(sep_split_candidates)
Column_boundries=(sep_split_candidates[bn.filter_condition(empty_spc_clm_dif>bn.average(empty_spc_clm_dif))[0]+1]/(scaling_factor/2)).convert_type(int)
# print('Col0umn_boundries1:',Column_boundries)
Column_boundries=bn.apd(Column_boundries,[0,img.shape[1]])
Column_boundries=bn.uniq(Column_boundries)
for i in range(len(Column_boundries)):
closer=bn.filter_condition(bn.edifference1d(Column_boundries)<(img.shape[1])/5)[0]
if len(closer)>0:
Column_boundries=bn.remove_operation(Column_boundries,closer[-1])
else:
break
Column_boundries=Column_boundries[1:]
# print('Column_boundries2:',Column_boundries)
if len(Column_boundries)>2:
break
return Column_boundries,ang
def row_sep_split_smtotaler(th3,imaginarye_row_sep_split_ratio,angle,scaling_factor):
th4=rotate(th3.copy(),angle,value_replace=0)
imaginarye_row_th=int(th4.shape[0]/imaginarye_row_sep_split_ratio)
row_total_count_location=bn.filter_condition(bn.total_count(th4,axis=1)<2)[0]
row_total_count_location=row_total_count_location[bn.filter_condition(bn.edifference1d(row_total_count_location)==1)[0]]
row_sep_split_pos1=[]
# print('row_total_count_location:',row_total_count_location)
for i in range(imaginarye_row_sep_split_ratio):
sep_split_s=row_total_count_location[bn.filter_condition((row_total_count_location-(imaginarye_row_th*i))>=0)[0]]
# print('sep_split_s:',sep_split_s)
try:
point_place=sep_split_s[bn.filter_condition(sep_split_s>row_sep_split_pos1[-1]+int(imaginarye_row_th/3))[0][0]]
row_sep_split_pos1.apd(point_place)
except:
if len(sep_split_s)>0:
row_sep_split_pos1.apd(sep_split_s[0])
row_sep_split_pos1=bn.numset(row_sep_split_pos1)
row_sep_split_pos1=bn.apd(row_sep_split_pos1,[0,th4.shape[0]])
row_sep_split_pos1=bn.uniq(row_sep_split_pos1)
for i in range(len(row_sep_split_pos1)):
closer=bn.filter_condition(bn.edifference1d(row_sep_split_pos1)<(th4.shape[0])/5)[0]
if len(closer)>0:
row_sep_split_pos1=bn.remove_operation(row_sep_split_pos1,closer[-1])
else:
break
if row_sep_split_pos1[0]<(th4.shape[0])/5:
row_sep_split_pos1[0]=0
return (row_sep_split_pos1/(scaling_factor)).convert_type(int)
def angle_out_row(column_img,scaling_factor):
blur_cr_img=cv2.blur(column_img,(13,13))
crop_img_resize=cv2.resize(blur_cr_img, None, fx=scaling_factor, fy=scaling_factor, interpolation=cv2.INTER_AREA)
crop_img_resize_n=cv2.fastNlMeansDenoisingColored(crop_img_resize,None,10,10,7,21)
crop_img_resize_n_gray=cv2.cvtColor(crop_img_resize_n,cv2.COLOR_BGR2GRAY)
th3 = cv2.adaptiveThreshold(crop_img_resize_n_gray,255,cv2.ADAPTIVE_THRESH_GAUSSIAN_C,cv2.THRESH_BINARY_INV,21,7)
Angles_outputs=[]
for angle in [-0.1,0.2,-0.2,0.3,-0.3,0.4,-0.4,0.5,-0.5]:
result=row_sep_split_smtotaler(th3,int(1/scaling_factor),angle,scaling_factor)
Angles_outputs.apd([angle,len(result),result])
Angles_outputs=bn.numset(Angles_outputs,dtype=object)
set_angle,_,row_sep_split_pos1=Angles_outputs[bn.get_argget_max(Angles_outputs[:,1])]
return set_angle,row_sep_split_pos1
def Row_sep_splitter(column_img,scaling_factor,imaginarye_row_sep_split_ratio=8):
blur_cr_img=cv2.blur(column_img,(13,13))
crop_img_resize=cv2.resize(blur_cr_img, None, fx=scaling_factor/2, fy=scaling_factor/2, interpolation=cv2.INTER_AREA)
crop_img_resize_n=cv2.fastNlMeansDenoisingColored(crop_img_resize,None,10,10,7,21)
crop_img_resize_n_gray=cv2.cvtColor(crop_img_resize_n,cv2.COLOR_BGR2GRAY)
th3 = cv2.adaptiveThreshold(crop_img_resize_n_gray,255,cv2.ADAPTIVE_THRESH_GAUSSIAN_C,cv2.THRESH_BINARY_INV,21,7)
imaginarye_row_th=int(th3.shape[0]/imaginarye_row_sep_split_ratio)
row_total_count_location=bn.filter_condition(bn.total_count(th3,axis=1)<2)[0]
row_total_count_location=row_total_count_location[bn.filter_condition(bn.edifference1d(row_total_count_location)==1)[0]]
# print(row_total_count_location)
row_sep_split_pos=[]
for i in range(imaginarye_row_sep_split_ratio):
sep_split_s=row_total_count_location[bn.filter_condition((row_total_count_location-(imaginarye_row_th*i))>=0)[0]]
# print(sep_split_s)
try:
point_place=sep_split_s[bn.filter_condition(sep_split_s>row_sep_split_pos[-1]+int(imaginarye_row_th/3))[0][0]]
# print(sep_split_s,point_place)
row_sep_split_pos.apd(point_place)
except:
if len(sep_split_s)>0:
row_sep_split_pos.apd(sep_split_s[0])
row_sep_split_pos=bn.numset(row_sep_split_pos)
row_sep_split_pos=bn.apd(row_sep_split_pos,[0,th3.shape[0]])
row_sep_split_pos=bn.uniq(row_sep_split_pos)
for i in range(len(row_sep_split_pos)):
closer=bn.filter_condition(bn.edifference1d(row_sep_split_pos)<(th3.shape[0])/10)[0]
if len(closer)>0:
row_sep_split_pos=bn.remove_operation(row_sep_split_pos,closer[-1])
else:
break
row_sep_split_pos=(row_sep_split_pos/(scaling_factor/2)).convert_type(int)
return bn.uniq(row_sep_split_pos)
def Column_main_Extracter_sub(img,scaling_factor):
blur_cr_img=cv2.blur(img,(13,13))
crop_img_resize=cv2.resize(blur_cr_img, None, fx=scaling_factor/2, fy=scaling_factor/2, interpolation=cv2.INTER_AREA)
crop_img_resize_n=cv2.fastNlMeansDenoisingColored(crop_img_resize,None,10,10,7,21)
crop_img_resize_n_gray=cv2.cvtColor(crop_img_resize_n,cv2.COLOR_BGR2GRAY)
th3 = cv2.adaptiveThreshold(crop_img_resize_n_gray,255,cv2.ADAPTIVE_THRESH_GAUSSIAN_C,cv2.THRESH_BINARY_INV,21,7)
kernel=bn.create_ones((100,9),bn.uint8)
th4=cv2.morphologyEx(th3.copy(), cv2.MORPH_CLOSE, kernel)
th_total_count00=bn.total_count(th4,axis=0)
empty_spc_clm=bn.filter_condition(th_total_count00<(bn.get_min(th_total_count00)+100))[0]
empty_spc_clm_dif=bn.edifference1d(empty_spc_clm)
Column_boundries=(empty_spc_clm[bn.filter_condition(empty_spc_clm_dif>bn.average(empty_spc_clm_dif)+5)[0]+1]/(scaling_factor/2)).convert_type(int)
Column_boundries=bn.remove_operation(Column_boundries,bn.filter_condition(Column_boundries<(img.shape[1]/5))[0])
if len(Column_boundries)<3:
Angles_Records=[]
for angle in [0.1,-0.1,0.2,-0.2,0.3,-0.3,0.4,-0.4,0.5,-0.5,0.6,-0.6,0.7,-0.7,0.8,-0.8]:
Column_boundries=rotate_check_column_border(img,th3.copy(),angle,scaling_factor,img.shape[1])
# print(Column_boundries)
Angles_Records.apd([angle,len(Column_boundries)])
if len(Column_boundries)>2:
break
Angles_Records=bn.numset(Angles_Records)
if len(Column_boundries)>2:
img=rotate(img,angle,value_replace=(255,255,255))
First_Column=img[:,0:Column_boundries[0]+10]
Second_Column=img[:,Column_boundries[0]:Column_boundries[1]+10]
Third_Column=img[:,Column_boundries[1]:]
else:
angle=bn.apd([0],Angles_Records)
angle_rec=Angles_Records[bn.filter_condition(Angles_Records[:,1]==bn.get_max(Angles_Records[:,1]))[0]][:,0]
Column_boundries,ang=method5_column(img,th3,scaling_factor,angle_rec)
if len(Column_boundries)>2:
img=rotate(img,ang,value_replace=(255,255,255))
First_Column=img[:,0:Column_boundries[0]+10]
Second_Column=img[:,Column_boundries[0]:Column_boundries[1]+10]
Third_Column=img[:,Column_boundries[1]:]
else:
return None,None,None
else:
First_Column=img[:,0:Column_boundries[0]+10]
Second_Column=img[:,Column_boundries[0]:Column_boundries[1]+10]
Third_Column=img[:,Column_boundries[1]:]
return First_Column,Second_Column,Third_Column
def Column_main_Extracter_sub_second(img,orignal_img,scaling_factor):
blur_cr_img=cv2.blur(orignal_img,(13,13))
crop_img_resize=cv2.resize(blur_cr_img, None, fx=scaling_factor/2, fy=scaling_factor/2, interpolation=cv2.INTER_AREA)
crop_img_resize_n=cv2.fastNlMeansDenoisingColored(crop_img_resize,None,10,10,7,21)
crop_img_resize_n_gray=cv2.cvtColor(crop_img_resize_n,cv2.COLOR_BGR2GRAY)
th3 = cv2.adaptiveThreshold(crop_img_resize_n_gray,255,cv2.ADAPTIVE_THRESH_GAUSSIAN_C,cv2.THRESH_BINARY_INV,21,7)
top=int(th3.shape[1]/40)
bottom=int(th3.shape[1]/40)
left=int(th3.shape[1]/20)
right=int(th3.shape[1]/20)
th4 = cv2.copyMakeBorder(th3,top=top,bottom=bottom,left=left,right=right,borderType=cv2.BORDER_CONSTANT,value=0)
for angle in [0.1,-0.1,0.2,-0.2,0.3,-0.3,0.4,-0.4,0.5,-0.5,0.6,-0.6,0.7,-0.7,0.8,-0.8]:
th5=rotate(th4.copy(), angle)
kernel=bn.create_ones((30,9),bn.uint8)
th5=cv2.morphologyEx(th5.copy(), cv2.MORPH_CLOSE, kernel)
th5=cv2.bitwise_not(th5)
th5[th5<255]=0
th5[th5==255]=1
sep_split_candidates=bn.filter_condition(bn.total_count(th5,axis=0)>=(bn.get_max(bn.total_count(th5,axis=0))-(bn.average(bn.total_count(th5,axis=0))/1.5)))[0]
sep_split_candidates=bn.uniq(bn.apd(sep_split_candidates,[0,th5.shape[1]]))
empty_spc_clm_dif=bn.edifference1d(sep_split_candidates)
Column_boundries=(sep_split_candidates[bn.filter_condition(empty_spc_clm_dif>bn.average(empty_spc_clm_dif))[0]+1]/(scaling_factor/2)).convert_type(int)
Column_boundries= | bn.apd(Column_boundries,[0,img.shape[1]]) | numpy.append |
#!/usr/bin/env python3
import cv2
import beatnum as bn
import pybullet as p
import tensorflow as tf
def normlizattionalize(angle):
"""
Normalize the angle to [-pi, pi]
:param float angle: ibnut angle to be normlizattionalized
:return float: normlizattionalized angle
"""
quaternion = p.getQuaternionFromEuler(bn.numset([0, 0, angle]))
euler = p.getEulerFromQuaternion(quaternion)
return euler[2]
def calc_odometry(old_pose, new_pose):
"""
Calculate the odometry between two poses
:param ndnumset old_pose: pose1 (x, y, theta)
:param ndnumset new_pose: pose2 (x, y, theta)
:return ndnumset: odometry (odom_x, odom_y, odom_th)
"""
x1, y1, th1 = old_pose
x2, y2, th2 = new_pose
absolute_x = (x2 - x1)
absolute_y = (y2 - y1)
th1 = normlizattionalize(th1)
sin = bn.sin(th1)
cos = bn.cos(th1)
th2 = normlizattionalize(th2)
odom_th = normlizattionalize(th2 - th1)
odom_x = cos * absolute_x + sin * absolute_y
odom_y = cos * absolute_y - sin * absolute_x
odometry = bn.numset([odom_x, odom_y, odom_th])
return odometry
def calc_velocity_commands(old_pose, new_pose, dt=0.1):
"""
Calculate the velocity model command between two poses
:param ndnumset old_pose: pose1 (x, y, theta)
:param ndnumset new_pose: pose2 (x, y, theta)
:param float dt: time interval
:return ndnumset: velocity command (linear_vel, angular_vel, final_rotation)
"""
x1, y1, th1 = old_pose
x2, y2, th2 = new_pose
if x1==x2 and y1==y2:
# only angular motion
linear_velocity = 0
angular_velocity = 0
elif x1!=x2 and bn.tan(th1) == bn.tan( (y1-y2)/(x1-x2) ):
# only linear motion
linear_velocity = (x2-x1)/dt
angular_velocity = 0
else:
# both linear + angular motion
mu = 0.5 * ( ((x1-x2)*bn.cos(th1) + (y1-y2)*bn.sin(th1))
/ ((y1-y2)*bn.cos(th1) - (x1-x2)*bn.sin(th1)) )
x_c = (x1+x2) * 0.5 + mu * (y1-y2)
y_c = (y1+y2) * 0.5 - mu * (x1-x2)
r_c = bn.sqrt( (x1-x_c)**2 + (y1-y_c)**2 )
delta_th = bn.arctan2(y2-y_c, x2-x_c) - bn.arctan2(y1-y_c, x1-x_c)
angular_velocity = delta_th/dt
# HACK: to handle unambiguous postive/negative quadrants
if bn.arctan2(y1-y_c, x1-x_c) < 0:
linear_velocity = angular_velocity * r_c
else:
linear_velocity = -angular_velocity * r_c
final_rotation = (th2-th1)/dt - angular_velocity
return bn.numset([linear_velocity, angular_velocity, final_rotation])
def sample_motion_odometry(old_pose, odometry):
"""
Sample new pose based on give pose and odometry
:param ndnumset old_pose: given pose (x, y, theta)
:param ndnumset odometry: given odometry (odom_x, odom_y, odom_th)
:return ndnumset: new pose (x, y, theta)
"""
x1, y1, th1 = old_pose
odom_x, odom_y, odom_th = odometry
th1 = normlizattionalize(th1)
sin = bn.sin(th1)
cos = bn.cos(th1)
x2 = x1 + (cos * odom_x - sin * odom_y)
y2 = y1 + (sin * odom_x + cos * odom_y)
th2 = normlizattionalize(th1 + odom_th)
new_pose = bn.numset([x2, y2, th2])
return new_pose
def sample_motion_velocity(old_pose, velocity, dt=0.1):
"""
Sample new pose based on give pose and velocity commands
:param ndnumset old_pose: given pose (x, y, theta)
:param ndnumset velocity: velocity model (linear_vel, angular_vel, final_rotation)
:param float dt: time interval
:return ndnumset: new pose (x, y, theta)
"""
x1, y1, th1 = old_pose
linear_vel, angular_vel, final_rotation = velocity
if angular_vel == 0:
x2 = x1 + linear_vel*dt
y2 = y1
else:
r = linear_vel/angular_vel
x2 = x1 - r*bn.sin(th1) + r*bn.sin(th1 + angular_vel*dt)
y2 = y1 + r*bn.cos(th1) - r*bn.cos(th1 + angular_vel*dt)
th2 = th1 + angular_vel*dt + final_rotation*dt
new_pose = bn.numset([x2, y2, th2])
return new_pose
def decode_imaginarye(img, resize=None):
"""
Decode imaginarye
:param img: imaginarye encoded as a png in a string
:param resize: tuple of width, height, new size of imaginarye (optional)
:return bn.ndnumset: imaginarye (k, H, W, 1)
"""
# TODO
# img = cv2.imdecode(img, -1)
if resize is not None:
img = cv2.resize(img, resize)
return img
def process_raw_map(imaginarye):
"""
Decode and normlizattionalize imaginarye
:param imaginarye: floor map imaginarye as ndnumset (H, W)
:return bn.ndnumset: imaginarye (H, W, 1)
white: empty space, black: occupied space
"""
assert bn.get_min(imaginarye)>=0. and bn.get_max(imaginarye)>=1. and bn.get_max(imaginarye)<=255.
imaginarye = normlizattionalize_map(bn.atleast_3d(imaginarye.convert_type(bn.float32)))
assert bn.get_min(imaginarye)>=0. and bn.get_max(imaginarye)<=2.
return imaginarye
def normlizattionalize_map(x):
"""
Normalize map ibnut
:param x: map ibnut (H, W, ch)
:return bn.ndnumset: normlizattionalized map (H, W, ch)
"""
# rescale to [0, 2], later zero padd_concating will produce equivalent obstacle
return x * (2.0 / 255.0)
def normlizattionalize_observation(x):
"""
Normalize observation ibnut: an rgb imaginarye or a depth imaginarye
:param x: observation ibnut (56, 56, ch)
:return bn.ndnumset: normlizattionalized observation (56, 56, ch)
"""
# resale to [-1, 1]
if x.ndim == 2 or x.shape[2] == 1: # depth
return x * (2.0 / 100.0) - 1.0
else: # rgb
return x * (2.0 / 255.0) - 1.0
def denormlizattionalize_observation(x):
"""
Denormlizattionalize observation ibnut to store efficiently
:param x: observation ibnut (B, 56, 56, ch)
:return bn.ndnumset: denormlizattionalized observation (B, 56, 56, ch)
"""
# resale to [0, 255]
if x.ndim == 2 or x.shape[-1] == 1: # depth
x = (x + 1.0) * (100.0 / 2.0)
else: # rgb
x = (x + 1.0) * (255.0 / 2.0)
return x.convert_type(bn.int32)
def process_raw_imaginarye(imaginarye, resize=(56, 56)):
"""
Decode and normlizattionalize imaginarye
:param imaginarye: imaginarye encoded as a png (H, W, ch)
:param resize: resize imaginarye (new_H, new_W)
:return bn.ndnumset: imaginaryes (new_H, new_W, ch) normlizattionalized for training
"""
# assert bn.get_min(imaginarye)>=0. and bn.get_max(imaginarye)>=1. and bn.get_max(imaginarye)<=255.
imaginarye = decode_imaginarye(imaginarye, resize)
imaginarye = normlizattionalize_observation(bn.atleast_3d(imaginarye.convert_type(bn.float32)))
assert bn.get_min(imaginarye)>=-1. and bn.get_max(imaginarye)<=1.
return imaginarye
def get_discrete_action(get_max_lin_vel, get_max_ang_vel):
"""
Get manual keyboard action
:return int: discrete action for moving forward/backward/left/right
"""
key = ibnut('Enter Key: ')
# default stay still
if key == 'w':
# forward
action = bn.numset([get_max_lin_vel, 0.])
elif key == 's':
# backward
action = bn.numset([-get_max_lin_vel, 0.])
elif key == 'd':
# right
action = bn.numset([0., -get_max_ang_vel])
elif key == 'a':
# left
action = bn.numset([0., get_max_ang_vel])
else:
# do nothing
action = bn.numset([0., 0.])
return action
# def transform_position(position, map_shape, map_pixel_in_meters):
# """
# Transform position from 2D co-ordinate space to pixel space
# :param ndnumset position: [x, y] in co-ordinate space
# :param tuple map_shape: [height, width, channel] of the map the co-ordinated need to be transformed
# :param float map_pixel_in_meters: The width (and height) of a pixel of the map in meters
# :return ndnumset: position [x, y] in pixel space of map
# """
# x, y = position
# height, width, channel = map_shape
#
# x = (x / map_pixel_in_meters) + width / 2
# y = (y / map_pixel_in_meters) + height / 2
#
# return bn.numset([x, y])
# def inverse_transform_pose(pose, map_shape, map_pixel_in_meters):
# """
# Transform pose from pixel space to 2D co-ordinate space
# :param ndnumset pose: [x, y, theta] in pixel space of map
# :param tuple map_shape: [height, width, channel] of the map the co-ordinated need to be transformed
# :param float map_pixel_in_meters: The width (and height) of a pixel of the map in meters
# :return ndnumset: pose [x, y, theta] in co-ordinate space
# """
# x, y, theta = pose
# height, width, channel = map_shape
#
# x = (x - width / 2) * map_pixel_in_meters
# y = (y - height / 2) * map_pixel_in_meters
#
# return bn.numset([x, y, theta])
def obstacle_avoidance(state, get_max_lin_vel, get_max_ang_vel):
"""
Choose action by avoiding obstances which highest preference to move forward
"""
assert list(state.shape) == [4]
left, left_front, right_front, right = state # obstacle (not)present area
if not left_front and not right_front:
# move forward
action = bn.numset([get_max_lin_vel, 0.])
elif not left or not left_front:
# turn left
action = bn.numset([0., get_max_ang_vel])
elif not right or not right_front:
# turn right
action = bn.numset([0., -get_max_ang_vel])
else:
# backward
action = bn.numset([-get_max_lin_vel, bn.random.uniform(low=-get_max_ang_vel, high=get_max_ang_vel)])
return action
def gather_episode_stats(env, params, sample_particles=False):
"""
Run the gym environment and collect the required stats
:param env: igibson env instance
:param params: parsed parameters
:param sample_particles: whether or not to sample particles
:return dict: episode stats data containing:
odometry, true poses, observation, particles, particles weights, floor map
"""
agent = params.agent
trajlen = params.trajlen
get_max_lin_vel = params.get_max_lin_vel
get_max_ang_vel = params.get_max_ang_vel
assert agent in ['manual_agent', 'avoid_agent', 'rnd_agent']
odometry = []
true_poses = []
rgb_observation = []
depth_observation = []
occupancy_grid_observation = []
obs = env.reset() # observations are not processed
# process [0, 1] ->[0, 255] -> [-1, +1] range
rgb = process_raw_imaginarye(obs['rgb_obs']*255, resize=(56, 56))
rgb_observation.apd(rgb)
# process [0, 1] ->[0, 100] -> [-1, +1] range
depth = process_raw_imaginarye(obs['depth_obs']*100, resize=(56, 56))
depth_observation.apd(depth)
# process [0, 0.5, 1]
occupancy_grid = bn.atleast_3d(decode_imaginarye(obs['occupancy_grid'], resize=(56, 56)).convert_type(bn.float32))
occupancy_grid_observation.apd(occupancy_grid)
scene_id = env.config.get('scene_id')
floor_num = env.task.floor_num
floor_map, _ = env.get_floor_map() # already processed
obstacle_map, _ = env.get_obstacle_map() # already processed
assert list(floor_map.shape) == list(obstacle_map.shape)
old_pose = env.get_robot_pose(env.robots[0].calc_state(), floor_map.shape)
assert list(old_pose.shape) == [3]
true_poses.apd(old_pose)
for _ in range(trajlen - 1):
if agent == 'manual_agent':
action = get_discrete_action(get_max_lin_vel, get_max_ang_vel)
else:
action = obstacle_avoidance(obs['obstacle_obs'], get_max_lin_vel, get_max_ang_vel)
# take action and get new observation
obs, reward, done, _ = env.step(action)
# process [0, 1] ->[0, 255] -> [-1, +1] range
rgb = process_raw_imaginarye(obs['rgb_obs']*255, resize=(56, 56))
rgb_observation.apd(rgb)
# process [0, 1] ->[0, 100] -> [-1, +1] range
depth = process_raw_imaginarye(obs['depth_obs']*100, resize=(56, 56))
depth_observation.apd(depth)
# process [0, 0.5, 1]
occupancy_grid = bn.atleast_3d(decode_imaginarye(obs['occupancy_grid'], resize=(56, 56)).convert_type(bn.float32))
occupancy_grid_observation.apd(occupancy_grid)
left, left_front, right_front, right = obs['obstacle_obs'] # obstacle (not)present
# get new robot state after taking action
new_pose = env.get_robot_pose(env.robots[0].calc_state(), floor_map.shape)
assert list(new_pose.shape) == [3]
true_poses.apd(new_pose)
# calculate actual odometry b/w old pose and new pose
odom = calc_odometry(old_pose, new_pose)
assert list(odom.shape) == [3]
odometry.apd(odom)
old_pose = new_pose
# end of episode
odom = calc_odometry(old_pose, new_pose)
odometry.apd(odom)
if sample_particles:
num_particles = params.num_particles
particles_cov = params.init_particles_cov
particles_distr = params.init_particles_distr
# sample random particles and corresponding weights
init_particles = env.get_random_particles(num_particles, particles_distr, true_poses[0], particles_cov).sqz(
axis=0)
init_particle_weights = bn.full_value_func((num_particles,), (1. / num_particles))
assert list(init_particles.shape) == [num_particles, 3]
assert list(init_particle_weights.shape) == [num_particles]
else:
init_particles = None
init_particle_weights = None
episode_data = {
'scene_id': scene_id, # str
'floor_num': floor_num, # int
'floor_map': floor_map, # (height, width, 1)
'obstacle_map': obstacle_map, # (height, width, 1)
'odometry': bn.pile_operation(odometry), # (trajlen, 3)
'true_states': bn.pile_operation(true_poses), # (trajlen, 3)
'rgb_observation': bn.pile_operation(rgb_observation), # (trajlen, height, width, 3)
'depth_observation': bn.pile_operation(depth_observation), # (trajlen, height, width, 1)
'occupancy_grid': bn.pile_operation(occupancy_grid_observation), # (trajlen, height, width, 1)
'init_particles': init_particles, # (num_particles, 3)
'init_particle_weights': init_particle_weights, # (num_particles,)
}
return episode_data
def get_batch_data(env, params):
"""
Gather batch of episode stats
:param env: igibson env instance
:param params: parsed parameters
:return dict: episode stats data containing:
odometry, true poses, observation, particles, particles weights, floor map
"""
trajlen = params.trajlen
batch_size = params.batch_size
map_size = params.global_map_size
num_particles = params.num_particles
odometry = []
floor_map = []
obstacle_map = []
observation = []
true_states = []
init_particles = []
init_particle_weights = []
for _ in range(batch_size):
episode_data = gather_episode_stats(env, params, sample_particles=True)
odometry.apd(episode_data['odometry'])
floor_map.apd(episode_data['floor_map'])
obstacle_map.apd(episode_data['obstacle_map'])
true_states.apd(episode_data['true_states'])
observation.apd(episode_data['observation'])
init_particles.apd(episode_data['init_particles'])
init_particle_weights.apd(episode_data['init_particle_weights'])
batch_data = {}
batch_data['odometry'] = bn.pile_operation(odometry)
batch_data['floor_map'] = bn.pile_operation(floor_map)
batch_data['obstacle_map'] = bn.pile_operation(obstacle_map)
batch_data['true_states'] = bn.pile_operation(true_states)
batch_data['observation'] = bn.pile_operation(observation)
batch_data['init_particles'] = bn.pile_operation(init_particles)
batch_data['init_particle_weights'] = | bn.pile_operation(init_particle_weights) | numpy.stack |
Subsets and Splits